scripts/checkpatch.pl

   1 #!/usr/bin/perl -w
   2 # (c) 2001, Dave Jones. (the file handling bit)
   3 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
   4 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
   5 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
   6 # Licensed under the terms of the GNU GPL License version 2
   7
   8 use strict;
   9 use POSIX;
  10
  11 my $P = $0;
  12 $P =~ s@.*/@@g;
  13
  14 my $V = '0.32';
  15
  16 use Getopt::Long qw(:config no_auto_abbrev);
  17
  18 my $quiet = 0;
  19 my $tree = 1;
  20 my $chk_signoff = 1;
  21 my $chk_patch = 1;
  22 my $tst_only;
  23 my $emacs = 0;
  24 my $terse = 0;
  25 my $file = 0;
  26 my $check = 0;
  27 my $summary = 1;
  28 my $mailback = 0;
  29 my $summary_file = 0;
  30 my $show_types = 0;
  31 my $fix = 0;
  32 my $fix_inplace = 0;
  33 my $root;
  34 my %debug;
  35 my %camelcase = ();
  36 my %use_type = ();
  37 my @use = ();
  38 my %ignore_type = ();
  39 my @ignore = ();
  40 my $help = 0;
  41 my $configuration_file = ".checkpatch.conf";
  42 my $max_line_length = 80;
  43 my $ignore_perl_version = 0;
  44 my $minimum_perl_version = 5.10.0;
  45
  46 sub help {
  47         my ($exitcode) = @_;
  48
  49         print << "EOM";
  50 Usage: $P [OPTION]... [FILE]...
  51 Version: $V
  52
  53 Options:
  54   -q, --quiet                quiet
  55   --no-tree                  run without a kernel tree
  56   --no-signoff               do not check for 'Signed-off-by' line
  57   --patch                    treat FILE as patchfile (default)
  58   --emacs                    emacs compile window format
  59   --terse                    one line per report
  60   -f, --file                 treat FILE as regular source file
  61   --subjective, --strict     enable more subjective tests
  62   --types TYPE(,TYPE2...)    show only these comma separated message types
  63   --ignore TYPE(,TYPE2...)   ignore various comma separated message types
  64   --max-line-length=n        set the maximum line length, if exceeded, warn
  65   --show-types               show the message "types" in the output
  66   --root=PATH                PATH to the kernel tree root
  67   --no-summary               suppress the per-file summary
  68   --mailback                 only produce a report in case of warnings/errors
  69   --summary-file             include the filename in summary
  70   --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
  71                              'values', 'possible', 'type', and 'attr' (default
  72                              is all off)
  73   --test-only=WORD           report only warnings/errors containing WORD
  74                              literally
  75   --fix                      EXPERIMENTAL - may create horrible results
  76                              If correctable single-line errors exist, create
  77                              "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
  78                              with potential errors corrected to the preferred
  79                              checkpatch style
  80   --fix-inplace              EXPERIMENTAL - may create horrible results
  81                              Is the same as --fix, but overwrites the input
  82                              file.  It's your fault if there's no backup or git
  83   --ignore-perl-version      override checking of perl version.  expect
  84                              runtime errors.
  85   -h, --help, --version      display this help and exit
  86
  87 When FILE is - read standard input.
  88 EOM
  89
  90         exit($exitcode);
  91 }
  92
  93 my $conf = which_conf($configuration_file);
  94 if (-f $conf) {
  95         my @conf_args;
  96         open(my $conffile, '<', "$conf")
  97             or warn "$P: Can't find a readable $configuration_file file $!\n";
  98
  99         while (<$conffile>) {
 100                 my $line = $_;
 101
 102                 $line =~ s/\s*\n?$//g;
 103                 $line =~ s/^\s*//g;
 104                 $line =~ s/\s+/ /g;
 105
 106                 next if ($line =~ m/^\s*#/);
 107                 next if ($line =~ m/^\s*$/);
 108
 109                 my @words = split(" ", $line);
 110                 foreach my $word (@words) {
 111                         last if ($word =~ m/^#/);
 112                         push (@conf_args, $word);
 113                 }
 114         }
 115         close($conffile);
 116         unshift(@ARGV, @conf_args) if @conf_args;
 117 }
 118
 119 GetOptions(
 120         'q|quiet+'      => \$quiet,
 121         'tree!'         => \$tree,
 122         'signoff!'      => \$chk_signoff,
 123         'patch!'        => \$chk_patch,
 124         'emacs!'        => \$emacs,
 125         'terse!'        => \$terse,
 126         'f|file!'       => \$file,
 127         'subjective!'   => \$check,
 128         'strict!'       => \$check,
 129         'ignore=s'      => \@ignore,
 130         'types=s'       => \@use,
 131         'show-types!'   => \$show_types,
 132         'max-line-length=i' => \$max_line_length,
 133         'root=s'        => \$root,
 134         'summary!'      => \$summary,
 135         'mailback!'     => \$mailback,
 136         'summary-file!' => \$summary_file,
 137         'fix!'          => \$fix,
 138         'fix-inplace!'  => \$fix_inplace,
 139         'ignore-perl-version!' => \$ignore_perl_version,
 140         'debug=s'       => \%debug,
 141         'test-only=s'   => \$tst_only,
 142         'h|help'        => \$help,
 143         'version'       => \$help
 144 ) or help(1);
 145
 146 help(0) if ($help);
 147
 148 $fix = 1 if ($fix_inplace);
 149
 150 my $exit = 0;
 151
 152 if ($^V && $^V lt $minimum_perl_version) {
 153         printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
 154         if (!$ignore_perl_version) {
 155                 exit(1);
 156         }
 157 }
 158
 159 if ($#ARGV < 0) {
 160         print "$P: no input files\n";
 161         exit(1);
 162 }
 163
 164 sub hash_save_array_words {
 165         my ($hashRef, $arrayRef) = @_;
 166
 167         my @array = split(/,/, join(',', @$arrayRef));
 168         foreach my $word (@array) {
 169                 $word =~ s/\s*\n?$//g;
 170                 $word =~ s/^\s*//g;
 171                 $word =~ s/\s+/ /g;
 172                 $word =~ tr/[a-z]/[A-Z]/;
 173
 174                 next if ($word =~ m/^\s*#/);
 175                 next if ($word =~ m/^\s*$/);
 176
 177                 $hashRef->{$word}++;
 178         }
 179 }
 180
 181 sub hash_show_words {
 182         my ($hashRef, $prefix) = @_;
 183
 184         if ($quiet == 0 && keys %$hashRef) {
 185                 print "NOTE: $prefix message types:";
 186                 foreach my $word (sort keys %$hashRef) {
 187                         print " $word";
 188                 }
 189                 print "\n\n";
 190         }
 191 }
 192
 193 hash_save_array_words(\%ignore_type, \@ignore);
 194 hash_save_array_words(\%use_type, \@use);
 195
 196 my $dbg_values = 0;
 197 my $dbg_possible = 0;
 198 my $dbg_type = 0;
 199 my $dbg_attr = 0;
 200 for my $key (keys %debug) {
 201         ## no critic
 202         eval "\${dbg_$key} = '$debug{$key}';";
 203         die "$@" if ($@);
 204 }
 205
 206 my $rpt_cleaners = 0;
 207
 208 if ($terse) {
 209         $emacs = 1;
 210         $quiet++;
 211 }
 212
 213 if ($tree) {
 214         if (defined $root) {
 215                 if (!top_of_kernel_tree($root)) {
 216                         die "$P: $root: --root does not point at a valid tree\n";
 217                 }
 218         } else {
 219                 if (top_of_kernel_tree('.')) {
 220                         $root = '.';
 221                 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
 222                                                 top_of_kernel_tree($1)) {
 223                         $root = $1;
 224                 }
 225         }
 226
 227         if (!defined $root) {
 228                 print "Must be run from the top-level dir. of a kernel tree\n";
 229                 exit(2);
 230         }
 231 }
 232
 233 my $emitted_corrupt = 0;
 234
 235 our $Ident      = qr{
 236                         [A-Za-z_][A-Za-z\d_]*
 237                         (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
 238                 }x;
 239 our $Storage    = qr{extern|static|asmlinkage};
 240 our $Sparse     = qr{
 241                         __user|
 242                         __kernel|
 243                         __force|
 244                         __iomem|
 245                         __must_check|
 246                         __init_refok|
 247                         __kprobes|
 248                         __ref|
 249                         __rcu
 250                 }x;
 251 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
 252 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
 253 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
 254 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
 255 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
 256
 257 # Notes to $Attribute:
 258 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
 259 our $Attribute  = qr{
 260                         const|
 261                         __percpu|
 262                         __nocast|
 263                         __safe|
 264                         __bitwise__|
 265                         __packed__|
 266                         __packed2__|
 267                         __naked|
 268                         __maybe_unused|
 269                         __always_unused|
 270                         __noreturn|
 271                         __used|
 272                         __cold|
 273                         __noclone|
 274                         __deprecated|
 275                         __read_mostly|
 276                         __kprobes|
 277                         $InitAttribute|
 278                         ____cacheline_aligned|
 279                         ____cacheline_aligned_in_smp|
 280                         ____cacheline_internodealigned_in_smp|
 281                         __weak
 282                   }x;
 283 our $Modifier;
 284 our $Inline     = qr{inline|__always_inline|noinline};
 285 our $Member     = qr{->$Ident|\.$Ident|\[[^]]*\]};
 286 our $Lval       = qr{$Ident(?:$Member)*};
 287
 288 our $Int_type   = qr{(?i)llu|ull|ll|lu|ul|l|u};
 289 our $Binary     = qr{(?i)0b[01]+$Int_type?};
 290 our $Hex        = qr{(?i)0x[0-9a-f]+$Int_type?};
 291 our $Int        = qr{[0-9]+$Int_type?};
 292 our $Float_hex  = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
 293 our $Float_dec  = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
 294 our $Float_int  = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
 295 our $Float      = qr{$Float_hex|$Float_dec|$Float_int};
 296 our $Constant   = qr{$Float|$Binary|$Hex|$Int};
 297 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
 298 our $Compare    = qr{<=|>=|==|!=|<|>};
 299 our $Arithmetic = qr{\+|-|\*|\/|%};
 300 our $Operators  = qr{
 301                         <=|>=|==|!=|
 302                         =>|->|<<|>>|<|>|!|~|
 303                         &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
 304                   }x;
 305
 306 our $NonptrType;
 307 our $NonptrTypeWithAttr;
 308 our $Type;
 309 our $Declare;
 310
 311 our $NON_ASCII_UTF8     = qr{
 312         [\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
 313         |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
 314         | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
 315         |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
 316         |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
 317         | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
 318         |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
 319 }x;
 320
 321 our $UTF8       = qr{
 322         [\x09\x0A\x0D\x20-\x7E]              # ASCII
 323         | $NON_ASCII_UTF8
 324 }x;
 325
 326 our $typeTypedefs = qr{(?x:
 327         (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
 328         atomic_t
 329 )};
 330
 331 our $logFunctions = qr{(?x:
 332         printk(?:_ratelimited|_once|)|
 333         (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
 334         WARN(?:_RATELIMIT|_ONCE|)|
 335         panic|
 336         MODULE_[A-Z_]+|
 337         seq_vprintf|seq_printf|seq_puts
 338 )};
 339
 340 our $signature_tags = qr{(?xi:
 341         Signed-off-by:|
 342         Acked-by:|
 343         Tested-by:|
 344         Reviewed-by:|
 345         Reported-by:|
 346         Suggested-by:|
 347         To:|
 348         Cc:
 349 )};
 350
 351 our @typeList = (
 352         qr{void},
 353         qr{(?:unsigned\s+)?char},
 354         qr{(?:unsigned\s+)?short},
 355         qr{(?:unsigned\s+)?int},
 356         qr{(?:unsigned\s+)?long},
 357         qr{(?:unsigned\s+)?long\s+int},
 358         qr{(?:unsigned\s+)?long\s+long},
 359         qr{(?:unsigned\s+)?long\s+long\s+int},
 360         qr{unsigned},
 361         qr{float},
 362         qr{double},
 363         qr{bool},
 364         qr{struct\s+$Ident},
 365         qr{union\s+$Ident},
 366         qr{enum\s+$Ident},
 367         qr{${Ident}_t},
 368         qr{${Ident}_handler},
 369         qr{${Ident}_handler_fn},
 370 );
 371 our @typeListWithAttr = (
 372         @typeList,
 373         qr{struct\s+$InitAttribute\s+$Ident},
 374         qr{union\s+$InitAttribute\s+$Ident},
 375 );
 376
 377 our @modifierList = (
 378         qr{fastcall},
 379 );
 380
 381 our $allowed_asm_includes = qr{(?x:
 382         irq|
 383         memory
 384 )};
 385 # memory.h: ARM has a custom one
 386
 387 sub build_types {
 388         my $mods = "(?x:  \n" . join("|\n  ", @modifierList) . "\n)";
 389         my $all = "(?x:  \n" . join("|\n  ", @typeList) . "\n)";
 390         my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
 391         $Modifier       = qr{(?:$Attribute|$Sparse|$mods)};
 392         $NonptrType     = qr{
 393                         (?:$Modifier\s+|const\s+)*
 394                         (?:
 395                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
 396                                 (?:$typeTypedefs\b)|
 397                                 (?:${all}\b)
 398                         )
 399                         (?:\s+$Modifier|\s+const)*
 400                   }x;
 401         $NonptrTypeWithAttr     = qr{
 402                         (?:$Modifier\s+|const\s+)*
 403                         (?:
 404                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
 405                                 (?:$typeTypedefs\b)|
 406                                 (?:${allWithAttr}\b)
 407                         )
 408                         (?:\s+$Modifier|\s+const)*
 409                   }x;
 410         $Type   = qr{
 411                         $NonptrType
 412                         (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)?
 413                         (?:\s+$Inline|\s+$Modifier)*
 414                   }x;
 415         $Declare        = qr{(?:$Storage\s+)?$Type};
 416 }
 417 build_types();
 418
 419 our $Typecast   = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
 420
 421 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
 422 # requires at least perl version v5.10.0
 423 # Any use must be runtime checked with $^V
 424
 425 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
 426 our $LvalOrFunc = qr{($Lval)\s*($balanced_parens{0,1})\s*};
 427 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
 428
 429 sub deparenthesize {
 430         my ($string) = @_;
 431         return "" if (!defined($string));
 432         $string =~ s@^\s*\(\s*@@g;
 433         $string =~ s@\s*\)\s*$@@g;
 434         $string =~ s@\s+@ @g;
 435         return $string;
 436 }
 437
 438 sub seed_camelcase_file {
 439         my ($file) = @_;
 440
 441         return if (!(-f $file));
 442
 443         local $/;
 444
 445         open(my $include_file, '<', "$file")
 446             or warn "$P: Can't read '$file' $!\n";
 447         my $text = <$include_file>;
 448         close($include_file);
 449
 450         my @lines = split('\n', $text);
 451
 452         foreach my $line (@lines) {
 453                 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
 454                 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
 455                         $camelcase{$1} = 1;
 456                 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
 457                         $camelcase{$1} = 1;
 458                 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
 459                         $camelcase{$1} = 1;
 460                 }
 461         }
 462 }
 463
 464 my $camelcase_seeded = 0;
 465 sub seed_camelcase_includes {
 466         return if ($camelcase_seeded);
 467
 468         my $files;
 469         my $camelcase_cache = "";
 470         my @include_files = ();
 471
 472         $camelcase_seeded = 1;
 473
 474         if (-e ".git") {
 475                 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
 476                 chomp $git_last_include_commit;
 477                 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
 478         } else {
 479                 my $last_mod_date = 0;
 480                 $files = `find $root/include -name "*.h"`;
 481                 @include_files = split('\n', $files);
 482                 foreach my $file (@include_files) {
 483                         my $date = POSIX::strftime("%Y%m%d%H%M",
 484                                                    localtime((stat $file)[9]));
 485                         $last_mod_date = $date if ($last_mod_date < $date);
 486                 }
 487                 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
 488         }
 489
 490         if ($camelcase_cache ne "" && -f $camelcase_cache) {
 491                 open(my $camelcase_file, '<', "$camelcase_cache")
 492                     or warn "$P: Can't read '$camelcase_cache' $!\n";
 493                 while (<$camelcase_file>) {
 494                         chomp;
 495                         $camelcase{$_} = 1;
 496                 }
 497                 close($camelcase_file);
 498
 499                 return;
 500         }
 501
 502         if (-e ".git") {
 503                 $files = `git ls-files "include/*.h"`;
 504                 @include_files = split('\n', $files);
 505         }
 506
 507         foreach my $file (@include_files) {
 508                 seed_camelcase_file($file);
 509         }
 510
 511         if ($camelcase_cache ne "") {
 512                 unlink glob ".checkpatch-camelcase.*";
 513                 open(my $camelcase_file, '>', "$camelcase_cache")
 514                     or warn "$P: Can't write '$camelcase_cache' $!\n";
 515                 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
 516                         print $camelcase_file ("$_\n");
 517                 }
 518                 close($camelcase_file);
 519         }
 520 }
 521
 522 $chk_signoff = 0 if ($file);
 523
 524 my @rawlines = ();
 525 my @lines = ();
 526 my @fixed = ();
 527 my $vname;
 528 for my $filename (@ARGV) {
 529         my $FILE;
 530         if ($file) {
 531                 open($FILE, '-|', "diff -u /dev/null $filename") ||
 532                         die "$P: $filename: diff failed - $!\n";
 533         } elsif ($filename eq '-') {
 534                 open($FILE, '<&STDIN');
 535         } else {
 536                 open($FILE, '<', "$filename") ||
 537                         die "$P: $filename: open failed - $!\n";
 538         }
 539         if ($filename eq '-') {
 540                 $vname = 'Your patch';
 541         } else {
 542                 $vname = $filename;
 543         }
 544         while (<$FILE>) {
 545                 chomp;
 546                 push(@rawlines, $_);
 547         }
 548         close($FILE);
 549         if (!process($filename)) {
 550                 $exit = 1;
 551         }
 552         @rawlines = ();
 553         @lines = ();
 554         @fixed = ();
 555 }
 556
 557 exit($exit);
 558
 559 sub top_of_kernel_tree {
 560         my ($root) = @_;
 561
 562         my @tree_check = (
 563                 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
 564                 "README", "Documentation", "arch", "include", "drivers",
 565                 "fs", "init", "ipc", "kernel", "lib", "scripts",
 566         );
 567
 568         foreach my $check (@tree_check) {
 569                 if (! -e $root . '/' . $check) {
 570                         return 0;
 571                 }
 572         }
 573         return 1;
 574 }
 575
 576 sub parse_email {
 577         my ($formatted_email) = @_;
 578
 579         my $name = "";
 580         my $address = "";
 581         my $comment = "";
 582
 583         if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
 584                 $name = $1;
 585                 $address = $2;
 586                 $comment = $3 if defined $3;
 587         } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
 588                 $address = $1;
 589                 $comment = $2 if defined $2;
 590         } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
 591                 $address = $1;
 592                 $comment = $2 if defined $2;
 593                 $formatted_email =~ s/$address.*$//;
 594                 $name = $formatted_email;
 595                 $name = trim($name);
 596                 $name =~ s/^\"|\"$//g;
 597                 # If there's a name left after stripping spaces and
 598                 # leading quotes, and the address doesn't have both
 599                 # leading and trailing angle brackets, the address
 600                 # is invalid. ie:
 601                 #   "joe smith joe@smith.com" bad
 602                 #   "joe smith <joe@smith.com" bad
 603                 if ($name ne "" && $address !~ /^<[^>]+>$/) {
 604                         $name = "";
 605                         $address = "";
 606                         $comment = "";
 607                 }
 608         }
 609
 610         $name = trim($name);
 611         $name =~ s/^\"|\"$//g;
 612         $address = trim($address);
 613         $address =~ s/^\<|\>$//g;
 614
 615         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
 616                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
 617                 $name = "\"$name\"";
 618         }
 619
 620         return ($name, $address, $comment);
 621 }
 622
 623 sub format_email {
 624         my ($name, $address) = @_;
 625
 626         my $formatted_email;
 627
 628         $name = trim($name);
 629         $name =~ s/^\"|\"$//g;
 630         $address = trim($address);
 631
 632         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
 633                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
 634                 $name = "\"$name\"";
 635         }
 636
 637         if ("$name" eq "") {
 638                 $formatted_email = "$address";
 639         } else {
 640                 $formatted_email = "$name <$address>";
 641         }
 642
 643         return $formatted_email;
 644 }
 645
 646 sub which_conf {
 647         my ($conf) = @_;
 648
 649         foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
 650                 if (-e "$path/$conf") {
 651                         return "$path/$conf";
 652                 }
 653         }
 654
 655         return "";
 656 }
 657
 658 sub expand_tabs {
 659         my ($str) = @_;
 660
 661         my $res = '';
 662         my $n = 0;
 663         for my $c (split(//, $str)) {
 664                 if ($c eq "\t") {
 665                         $res .= ' ';
 666                         $n++;
 667                         for (; ($n % 8) != 0; $n++) {
 668                                 $res .= ' ';
 669                         }
 670                         next;
 671                 }
 672                 $res .= $c;
 673                 $n++;
 674         }
 675
 676         return $res;
 677 }
 678 sub copy_spacing {
 679         (my $res = shift) =~ tr/\t/ /c;
 680         return $res;
 681 }
 682
 683 sub line_stats {
 684         my ($line) = @_;
 685
 686         # Drop the diff line leader and expand tabs
 687         $line =~ s/^.//;
 688         $line = expand_tabs($line);
 689
 690         # Pick the indent from the front of the line.
 691         my ($white) = ($line =~ /^(\s*)/);
 692
 693         return (length($line), length($white));
 694 }
 695
 696 my $sanitise_quote = '';
 697
 698 sub sanitise_line_reset {
 699         my ($in_comment) = @_;
 700
 701         if ($in_comment) {
 702                 $sanitise_quote = '*/';
 703         } else {
 704                 $sanitise_quote = '';
 705         }
 706 }
 707 sub sanitise_line {
 708         my ($line) = @_;
 709
 710         my $res = '';
 711         my $l = '';
 712
 713         my $qlen = 0;
 714         my $off = 0;
 715         my $c;
 716
 717         # Always copy over the diff marker.
 718         $res = substr($line, 0, 1);
 719
 720         for ($off = 1; $off < length($line); $off++) {
 721                 $c = substr($line, $off, 1);
 722
 723                 # Comments we are wacking completly including the begin
 724                 # and end, all to $;.
 725                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
 726                         $sanitise_quote = '*/';
 727
 728                         substr($res, $off, 2, "$;$;");
 729                         $off++;
 730                         next;
 731                 }
 732                 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
 733                         $sanitise_quote = '';
 734                         substr($res, $off, 2, "$;$;");
 735                         $off++;
 736                         next;
 737                 }
 738                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
 739                         $sanitise_quote = '//';
 740
 741                         substr($res, $off, 2, $sanitise_quote);
 742                         $off++;
 743                         next;
 744                 }
 745
 746                 # A \ in a string means ignore the next character.
 747                 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
 748                     $c eq "\\") {
 749                         substr($res, $off, 2, 'XX');
 750                         $off++;
 751                         next;
 752                 }
 753                 # Regular quotes.
 754                 if ($c eq "'" || $c eq '"') {
 755                         if ($sanitise_quote eq '') {
 756                                 $sanitise_quote = $c;
 757
 758                                 substr($res, $off, 1, $c);
 759                                 next;
 760                         } elsif ($sanitise_quote eq $c) {
 761                                 $sanitise_quote = '';
 762                         }
 763                 }
 764
 765                 #print "c<$c> SQ<$sanitise_quote>\n";
 766                 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
 767                         substr($res, $off, 1, $;);
 768                 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
 769                         substr($res, $off, 1, $;);
 770                 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
 771                         substr($res, $off, 1, 'X');
 772                 } else {
 773                         substr($res, $off, 1, $c);
 774                 }
 775         }
 776
 777         if ($sanitise_quote eq '//') {
 778                 $sanitise_quote = '';
 779         }
 780
 781         # The pathname on a #include may be surrounded by '<' and '>'.
 782         if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
 783                 my $clean = 'X' x length($1);
 784                 $res =~ s@\<.*\>@<$clean>@;
 785
 786         # The whole of a #error is a string.
 787         } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
 788                 my $clean = 'X' x length($1);
 789                 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
 790         }
 791
 792         return $res;
 793 }
 794
 795 sub get_quoted_string {
 796         my ($line, $rawline) = @_;
 797
 798         return "" if ($line !~ m/(\"[X]+\")/g);
 799         return substr($rawline, $-[0], $+[0] - $-[0]);
 800 }
 801
 802 sub ctx_statement_block {
 803         my ($linenr, $remain, $off) = @_;
 804         my $line = $linenr - 1;
 805         my $blk = '';
 806         my $soff = $off;
 807         my $coff = $off - 1;
 808         my $coff_set = 0;
 809
 810         my $loff = 0;
 811
 812         my $type = '';
 813         my $level = 0;
 814         my @stack = ();
 815         my $p;
 816         my $c;
 817         my $len = 0;
 818
 819         my $remainder;
 820         while (1) {
 821                 @stack = (['', 0]) if ($#stack == -1);
 822
 823                 #warn "CSB: blk<$blk> remain<$remain>\n";
 824                 # If we are about to drop off the end, pull in more
 825                 # context.
 826                 if ($off >= $len) {
 827                         for (; $remain > 0; $line++) {
 828                                 last if (!defined $lines[$line]);
 829                                 next if ($lines[$line] =~ /^-/);
 830                                 $remain--;
 831                                 $loff = $len;
 832                                 $blk .= $lines[$line] . "\n";
 833                                 $len = length($blk);
 834                                 $line++;
 835                                 last;
 836                         }
 837                         # Bail if there is no further context.
 838                         #warn "CSB: blk<$blk> off<$off> len<$len>\n";
 839                         if ($off >= $len) {
 840                                 last;
 841                         }
 842                         if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
 843                                 $level++;
 844                                 $type = '#';
 845                         }
 846                 }
 847                 $p = $c;
 848                 $c = substr($blk, $off, 1);
 849                 $remainder = substr($blk, $off);
 850
 851                 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
 852
 853                 # Handle nested #if/#else.
 854                 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
 855                         push(@stack, [ $type, $level ]);
 856                 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
 857                         ($type, $level) = @{$stack[$#stack - 1]};
 858                 } elsif ($remainder =~ /^#\s*endif\b/) {
 859                         ($type, $level) = @{pop(@stack)};
 860                 }
 861
 862                 # Statement ends at the ';' or a close '}' at the
 863                 # outermost level.
 864                 if ($level == 0 && $c eq ';') {
 865                         last;
 866                 }
 867
 868                 # An else is really a conditional as long as its not else if
 869                 if ($level == 0 && $coff_set == 0 &&
 870                                 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
 871                                 $remainder =~ /^(else)(?:\s|{)/ &&
 872                                 $remainder !~ /^else\s+if\b/) {
 873                         $coff = $off + length($1) - 1;
 874                         $coff_set = 1;
 875                         #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
 876                         #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
 877                 }
 878
 879                 if (($type eq '' || $type eq '(') && $c eq '(') {
 880                         $level++;
 881                         $type = '(';
 882                 }
 883                 if ($type eq '(' && $c eq ')') {
 884                         $level--;
 885                         $type = ($level != 0)? '(' : '';
 886
 887                         if ($level == 0 && $coff < $soff) {
 888                                 $coff = $off;
 889                                 $coff_set = 1;
 890                                 #warn "CSB: mark coff<$coff>\n";
 891                         }
 892                 }
 893                 if (($type eq '' || $type eq '{') && $c eq '{') {
 894                         $level++;
 895                         $type = '{';
 896                 }
 897                 if ($type eq '{' && $c eq '}') {
 898                         $level--;
 899                         $type = ($level != 0)? '{' : '';
 900
 901                         if ($level == 0) {
 902                                 if (substr($blk, $off + 1, 1) eq ';') {
 903                                         $off++;
 904                                 }
 905                                 last;
 906                         }
 907                 }
 908                 # Preprocessor commands end at the newline unless escaped.
 909                 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
 910                         $level--;
 911                         $type = '';
 912                         $off++;
 913                         last;
 914                 }
 915                 $off++;
 916         }
 917         # We are truly at the end, so shuffle to the next line.
 918         if ($off == $len) {
 919                 $loff = $len + 1;
 920                 $line++;
 921                 $remain--;
 922         }
 923
 924         my $statement = substr($blk, $soff, $off - $soff + 1);
 925         my $condition = substr($blk, $soff, $coff - $soff + 1);
 926
 927         #warn "STATEMENT<$statement>\n";
 928         #warn "CONDITION<$condition>\n";
 929
 930         #print "coff<$coff> soff<$off> loff<$loff>\n";
 931
 932         return ($statement, $condition,
 933                         $line, $remain + 1, $off - $loff + 1, $level);
 934 }
 935
 936 sub statement_lines {
 937         my ($stmt) = @_;
 938
 939         # Strip the diff line prefixes and rip blank lines at start and end.
 940         $stmt =~ s/(^|\n)./$1/g;
 941         $stmt =~ s/^\s*//;
 942         $stmt =~ s/\s*$//;
 943
 944         my @stmt_lines = ($stmt =~ /\n/g);
 945
 946         return $#stmt_lines + 2;
 947 }
 948
 949 sub statement_rawlines {
 950         my ($stmt) = @_;
 951
 952         my @stmt_lines = ($stmt =~ /\n/g);
 953
 954         return $#stmt_lines + 2;
 955 }
 956
 957 sub statement_block_size {
 958         my ($stmt) = @_;
 959
 960         $stmt =~ s/(^|\n)./$1/g;
 961         $stmt =~ s/^\s*{//;
 962         $stmt =~ s/}\s*$//;
 963         $stmt =~ s/^\s*//;
 964         $stmt =~ s/\s*$//;
 965
 966         my @stmt_lines = ($stmt =~ /\n/g);
 967         my @stmt_statements = ($stmt =~ /;/g);
 968
 969         my $stmt_lines = $#stmt_lines + 2;
 970         my $stmt_statements = $#stmt_statements + 1;
 971
 972         if ($stmt_lines > $stmt_statements) {
 973                 return $stmt_lines;
 974         } else {
 975                 return $stmt_statements;
 976         }
 977 }
 978
 979 sub ctx_statement_full {
 980         my ($linenr, $remain, $off) = @_;
 981         my ($statement, $condition, $level);
 982
 983         my (@chunks);
 984
 985         # Grab the first conditional/block pair.
 986         ($statement, $condition, $linenr, $remain, $off, $level) =
 987                                 ctx_statement_block($linenr, $remain, $off);
 988         #print "F: c<$condition> s<$statement> remain<$remain>\n";
 989         push(@chunks, [ $condition, $statement ]);
 990         if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
 991                 return ($level, $linenr, @chunks);
 992         }
 993
 994         # Pull in the following conditional/block pairs and see if they
 995         # could continue the statement.
 996         for (;;) {
 997                 ($statement, $condition, $linenr, $remain, $off, $level) =
 998                                 ctx_statement_block($linenr, $remain, $off);
 999                 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1000                 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1001                 #print "C: push\n";
1002                 push(@chunks, [ $condition, $statement ]);
1003         }
1004
1005         return ($level, $linenr, @chunks);
1006 }
1007
1008 sub ctx_block_get {
1009         my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1010         my $line;
1011         my $start = $linenr - 1;
1012         my $blk = '';
1013         my @o;
1014         my @c;
1015         my @res = ();
1016
1017         my $level = 0;
1018         my @stack = ($level);
1019         for ($line = $start; $remain > 0; $line++) {
1020                 next if ($rawlines[$line] =~ /^-/);
1021                 $remain--;
1022
1023                 $blk .= $rawlines[$line];
1024
1025                 # Handle nested #if/#else.
1026                 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1027                         push(@stack, $level);
1028                 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1029                         $level = $stack[$#stack - 1];
1030                 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1031                         $level = pop(@stack);
1032                 }
1033
1034                 foreach my $c (split(//, $lines[$line])) {
1035                         ##print "C<$c>L<$level><$open$close>O<$off>\n";
1036                         if ($off > 0) {
1037                                 $off--;
1038                                 next;
1039                         }
1040
1041                         if ($c eq $close && $level > 0) {
1042                                 $level--;
1043                                 last if ($level == 0);
1044                         } elsif ($c eq $open) {
1045                                 $level++;
1046                         }
1047                 }
1048
1049                 if (!$outer || $level <= 1) {
1050                         push(@res, $rawlines[$line]);
1051                 }
1052
1053                 last if ($level == 0);
1054         }
1055
1056         return ($level, @res);
1057 }
1058 sub ctx_block_outer {
1059         my ($linenr, $remain) = @_;
1060
1061         my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1062         return @r;
1063 }
1064 sub ctx_block {
1065         my ($linenr, $remain) = @_;
1066
1067         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1068         return @r;
1069 }
1070 sub ctx_statement {
1071         my ($linenr, $remain, $off) = @_;
1072
1073         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1074         return @r;
1075 }
1076 sub ctx_block_level {
1077         my ($linenr, $remain) = @_;
1078
1079         return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1080 }
1081 sub ctx_statement_level {
1082         my ($linenr, $remain, $off) = @_;
1083
1084         return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1085 }
1086
1087 sub ctx_locate_comment {
1088         my ($first_line, $end_line) = @_;
1089
1090         # Catch a comment on the end of the line itself.
1091         my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1092         return $current_comment if (defined $current_comment);
1093
1094         # Look through the context and try and figure out if there is a
1095         # comment.
1096         my $in_comment = 0;
1097         $current_comment = '';
1098         for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1099                 my $line = $rawlines[$linenr - 1];
1100                 #warn "           $line\n";
1101                 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1102                         $in_comment = 1;
1103                 }
1104                 if ($line =~ m@/\*@) {
1105                         $in_comment = 1;
1106                 }
1107                 if (!$in_comment && $current_comment ne '') {
1108                         $current_comment = '';
1109                 }
1110                 $current_comment .= $line . "\n" if ($in_comment);
1111                 if ($line =~ m@\*/@) {
1112                         $in_comment = 0;
1113                 }
1114         }
1115
1116         chomp($current_comment);
1117         return($current_comment);
1118 }
1119 sub ctx_has_comment {
1120         my ($first_line, $end_line) = @_;
1121         my $cmt = ctx_locate_comment($first_line, $end_line);
1122
1123         ##print "LINE: $rawlines[$end_line - 1 ]\n";
1124         ##print "CMMT: $cmt\n";
1125
1126         return ($cmt ne '');
1127 }
1128
1129 sub raw_line {
1130         my ($linenr, $cnt) = @_;
1131
1132         my $offset = $linenr - 1;
1133         $cnt++;
1134
1135         my $line;
1136         while ($cnt) {
1137                 $line = $rawlines[$offset++];
1138                 next if (defined($line) && $line =~ /^-/);
1139                 $cnt--;
1140         }
1141
1142         return $line;
1143 }
1144
1145 sub cat_vet {
1146         my ($vet) = @_;
1147         my ($res, $coded);
1148
1149         $res = '';
1150         while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1151                 $res .= $1;
1152                 if ($2 ne '') {
1153                         $coded = sprintf("^%c", unpack('C', $2) + 64);
1154                         $res .= $coded;
1155                 }
1156         }
1157         $res =~ s/$/\$/;
1158
1159         return $res;
1160 }
1161
1162 my $av_preprocessor = 0;
1163 my $av_pending;
1164 my @av_paren_type;
1165 my $av_pend_colon;
1166
1167 sub annotate_reset {
1168         $av_preprocessor = 0;
1169         $av_pending = '_';
1170         @av_paren_type = ('E');
1171         $av_pend_colon = 'O';
1172 }
1173
1174 sub annotate_values {
1175         my ($stream, $type) = @_;
1176
1177         my $res;
1178         my $var = '_' x length($stream);
1179         my $cur = $stream;
1180
1181         print "$stream\n" if ($dbg_values > 1);
1182
1183         while (length($cur)) {
1184                 @av_paren_type = ('E') if ($#av_paren_type < 0);
1185                 print " <" . join('', @av_paren_type) .
1186                                 "> <$type> <$av_pending>" if ($dbg_values > 1);
1187                 if ($cur =~ /^(\s+)/o) {
1188                         print "WS($1)\n" if ($dbg_values > 1);
1189                         if ($1 =~ /\n/ && $av_preprocessor) {
1190                                 $type = pop(@av_paren_type);
1191                                 $av_preprocessor = 0;
1192                         }
1193
1194                 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1195                         print "CAST($1)\n" if ($dbg_values > 1);
1196                         push(@av_paren_type, $type);
1197                         $type = 'c';
1198
1199                 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1200                         print "DECLARE($1)\n" if ($dbg_values > 1);
1201                         $type = 'T';
1202
1203                 } elsif ($cur =~ /^($Modifier)\s*/) {
1204                         print "MODIFIER($1)\n" if ($dbg_values > 1);
1205                         $type = 'T';
1206
1207                 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1208                         print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1209                         $av_preprocessor = 1;
1210                         push(@av_paren_type, $type);
1211                         if ($2 ne '') {
1212                                 $av_pending = 'N';
1213                         }
1214                         $type = 'E';
1215
1216                 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1217                         print "UNDEF($1)\n" if ($dbg_values > 1);
1218                         $av_preprocessor = 1;
1219                         push(@av_paren_type, $type);
1220
1221                 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1222                         print "PRE_START($1)\n" if ($dbg_values > 1);
1223                         $av_preprocessor = 1;
1224
1225                         push(@av_paren_type, $type);
1226                         push(@av_paren_type, $type);
1227                         $type = 'E';
1228
1229                 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1230                         print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1231                         $av_preprocessor = 1;
1232
1233                         push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1234
1235                         $type = 'E';
1236
1237                 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1238                         print "PRE_END($1)\n" if ($dbg_values > 1);
1239
1240                         $av_preprocessor = 1;
1241
1242                         # Assume all arms of the conditional end as this
1243                         # one does, and continue as if the #endif was not here.
1244                         pop(@av_paren_type);
1245                         push(@av_paren_type, $type);
1246                         $type = 'E';
1247
1248                 } elsif ($cur =~ /^(\\\n)/o) {
1249                         print "PRECONT($1)\n" if ($dbg_values > 1);
1250
1251                 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1252                         print "ATTR($1)\n" if ($dbg_values > 1);
1253                         $av_pending = $type;
1254                         $type = 'N';
1255
1256                 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1257                         print "SIZEOF($1)\n" if ($dbg_values > 1);
1258                         if (defined $2) {
1259                                 $av_pending = 'V';
1260                         }
1261                         $type = 'N';
1262
1263                 } elsif ($cur =~ /^(if|while|for)\b/o) {
1264                         print "COND($1)\n" if ($dbg_values > 1);
1265                         $av_pending = 'E';
1266                         $type = 'N';
1267
1268                 } elsif ($cur =~/^(case)/o) {
1269                         print "CASE($1)\n" if ($dbg_values > 1);
1270                         $av_pend_colon = 'C';
1271                         $type = 'N';
1272
1273                 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1274                         print "KEYWORD($1)\n" if ($dbg_values > 1);
1275                         $type = 'N';
1276
1277                 } elsif ($cur =~ /^(\()/o) {
1278                         print "PAREN('$1')\n" if ($dbg_values > 1);
1279                         push(@av_paren_type, $av_pending);
1280                         $av_pending = '_';
1281                         $type = 'N';
1282
1283                 } elsif ($cur =~ /^(\))/o) {
1284                         my $new_type = pop(@av_paren_type);
1285                         if ($new_type ne '_') {
1286                                 $type = $new_type;
1287                                 print "PAREN('$1') -> $type\n"
1288                                                         if ($dbg_values > 1);
1289                         } else {
1290                                 print "PAREN('$1')\n" if ($dbg_values > 1);
1291                         }
1292
1293                 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1294                         print "FUNC($1)\n" if ($dbg_values > 1);
1295                         $type = 'V';
1296                         $av_pending = 'V';
1297
1298                 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1299                         if (defined $2 && $type eq 'C' || $type eq 'T') {
1300                                 $av_pend_colon = 'B';
1301                         } elsif ($type eq 'E') {
1302                                 $av_pend_colon = 'L';
1303                         }
1304                         print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1305                         $type = 'V';
1306
1307                 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1308                         print "IDENT($1)\n" if ($dbg_values > 1);
1309                         $type = 'V';
1310
1311                 } elsif ($cur =~ /^($Assignment)/o) {
1312                         print "ASSIGN($1)\n" if ($dbg_values > 1);
1313                         $type = 'N';
1314
1315                 } elsif ($cur =~/^(;|{|})/) {
1316                         print "END($1)\n" if ($dbg_values > 1);
1317                         $type = 'E';
1318                         $av_pend_colon = 'O';
1319
1320                 } elsif ($cur =~/^(,)/) {
1321                         print "COMMA($1)\n" if ($dbg_values > 1);
1322                         $type = 'C';
1323
1324                 } elsif ($cur =~ /^(\?)/o) {
1325                         print "QUESTION($1)\n" if ($dbg_values > 1);
1326                         $type = 'N';
1327
1328                 } elsif ($cur =~ /^(:)/o) {
1329                         print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1330
1331                         substr($var, length($res), 1, $av_pend_colon);
1332                         if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1333                                 $type = 'E';
1334                         } else {
1335                                 $type = 'N';
1336                         }
1337                         $av_pend_colon = 'O';
1338
1339                 } elsif ($cur =~ /^(\[)/o) {
1340                         print "CLOSE($1)\n" if ($dbg_values > 1);
1341                         $type = 'N';
1342
1343                 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1344                         my $variant;
1345
1346                         print "OPV($1)\n" if ($dbg_values > 1);
1347                         if ($type eq 'V') {
1348                                 $variant = 'B';
1349                         } else {
1350                                 $variant = 'U';
1351                         }
1352
1353                         substr($var, length($res), 1, $variant);
1354                         $type = 'N';
1355
1356                 } elsif ($cur =~ /^($Operators)/o) {
1357                         print "OP($1)\n" if ($dbg_values > 1);
1358                         if ($1 ne '++' && $1 ne '--') {
1359                                 $type = 'N';
1360                         }
1361
1362                 } elsif ($cur =~ /(^.)/o) {
1363                         print "C($1)\n" if ($dbg_values > 1);
1364                 }
1365                 if (defined $1) {
1366                         $cur = substr($cur, length($1));
1367                         $res .= $type x length($1);
1368                 }
1369         }
1370
1371         return ($res, $var);
1372 }
1373
1374 sub possible {
1375         my ($possible, $line) = @_;
1376         my $notPermitted = qr{(?:
1377                 ^(?:
1378                         $Modifier|
1379                         $Storage|
1380                         $Type|
1381                         DEFINE_\S+
1382                 )$|
1383                 ^(?:
1384                         goto|
1385                         return|
1386                         case|
1387                         else|
1388                         asm|__asm__|
1389                         do|
1390                         \#|
1391                         \#\#|
1392                 )(?:\s|$)|
1393                 ^(?:typedef|struct|enum)\b
1394             )}x;
1395         warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1396         if ($possible !~ $notPermitted) {
1397                 # Check for modifiers.
1398                 $possible =~ s/\s*$Storage\s*//g;
1399                 $possible =~ s/\s*$Sparse\s*//g;
1400                 if ($possible =~ /^\s*$/) {
1401
1402                 } elsif ($possible =~ /\s/) {
1403                         $possible =~ s/\s*$Type\s*//g;
1404                         for my $modifier (split(' ', $possible)) {
1405                                 if ($modifier !~ $notPermitted) {
1406                                         warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1407                                         push(@modifierList, $modifier);
1408                                 }
1409                         }
1410
1411                 } else {
1412                         warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1413                         push(@typeList, $possible);
1414                 }
1415                 build_types();
1416         } else {
1417                 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1418         }
1419 }
1420
1421 my $prefix = '';
1422
1423 sub show_type {
1424         return defined $use_type{$_[0]} if (scalar keys %use_type > 0);
1425
1426         return !defined $ignore_type{$_[0]};
1427 }
1428
1429 sub report {
1430         if (!show_type($_[1]) ||
1431             (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {
1432                 return 0;
1433         }
1434         my $line;
1435         if ($show_types) {
1436                 $line = "$prefix$_[0]:$_[1]: $_[2]\n";
1437         } else {
1438                 $line = "$prefix$_[0]: $_[2]\n";
1439         }
1440         $line = (split('\n', $line))[0] . "\n" if ($terse);
1441
1442         push(our @report, $line);
1443
1444         return 1;
1445 }
1446 sub report_dump {
1447         our @report;
1448 }
1449
1450 sub ERROR {
1451         if (report("ERROR", $_[0], $_[1])) {
1452                 our $clean = 0;
1453                 our $cnt_error++;
1454                 return 1;
1455         }
1456         return 0;
1457 }
1458 sub WARN {
1459         if (report("WARNING", $_[0], $_[1])) {
1460                 our $clean = 0;
1461                 our $cnt_warn++;
1462                 return 1;
1463         }
1464         return 0;
1465 }
1466 sub CHK {
1467         if ($check && report("CHECK", $_[0], $_[1])) {
1468                 our $clean = 0;
1469                 our $cnt_chk++;
1470                 return 1;
1471         }
1472         return 0;
1473 }
1474
1475 sub check_absolute_file {
1476         my ($absolute, $herecurr) = @_;
1477         my $file = $absolute;
1478
1479         ##print "absolute<$absolute>\n";
1480
1481         # See if any suffix of this path is a path within the tree.
1482         while ($file =~ s@^[^/]*/@@) {
1483                 if (-f "$root/$file") {
1484                         ##print "file<$file>\n";
1485                         last;
1486                 }
1487         }
1488         if (! -f _)  {
1489                 return 0;
1490         }
1491
1492         # It is, so see if the prefix is acceptable.
1493         my $prefix = $absolute;
1494         substr($prefix, -length($file)) = '';
1495
1496         ##print "prefix<$prefix>\n";
1497         if ($prefix ne ".../") {
1498                 WARN("USE_RELATIVE_PATH",
1499                      "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1500         }
1501 }
1502
1503 sub trim {
1504         my ($string) = @_;
1505
1506         $string =~ s/^\s+|\s+$//g;
1507
1508         return $string;
1509 }
1510
1511 sub ltrim {
1512         my ($string) = @_;
1513
1514         $string =~ s/^\s+//;
1515
1516         return $string;
1517 }
1518
1519 sub rtrim {
1520         my ($string) = @_;
1521
1522         $string =~ s/\s+$//;
1523
1524         return $string;
1525 }
1526
1527 sub string_find_replace {
1528         my ($string, $find, $replace) = @_;
1529
1530         $string =~ s/$find/$replace/g;
1531
1532         return $string;
1533 }
1534
1535 sub tabify {
1536         my ($leading) = @_;
1537
1538         my $source_indent = 8;
1539         my $max_spaces_before_tab = $source_indent - 1;
1540         my $spaces_to_tab = " " x $source_indent;
1541
1542         #convert leading spaces to tabs
1543         1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1544         #Remove spaces before a tab
1545         1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1546
1547         return "$leading";
1548 }
1549
1550 sub pos_last_openparen {
1551         my ($line) = @_;
1552
1553         my $pos = 0;
1554
1555         my $opens = $line =~ tr/\(/\(/;
1556         my $closes = $line =~ tr/\)/\)/;
1557
1558         my $last_openparen = 0;
1559
1560         if (($opens == 0) || ($closes >= $opens)) {
1561                 return -1;
1562         }
1563
1564         my $len = length($line);
1565
1566         for ($pos = 0; $pos < $len; $pos++) {
1567                 my $string = substr($line, $pos);
1568                 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1569                         $pos += length($1) - 1;
1570                 } elsif (substr($line, $pos, 1) eq '(') {
1571                         $last_openparen = $pos;
1572                 } elsif (index($string, '(') == -1) {
1573                         last;
1574                 }
1575         }
1576
1577         return $last_openparen + 1;
1578 }
1579
1580 sub process {
1581         my $filename = shift;
1582
1583         my $linenr=0;
1584         my $prevline="";
1585         my $prevrawline="";
1586         my $stashline="";
1587         my $stashrawline="";
1588
1589         my $length;
1590         my $indent;
1591         my $previndent=0;
1592         my $stashindent=0;
1593
1594         our $clean = 1;
1595         my $signoff = 0;
1596         my $is_patch = 0;
1597
1598         my $in_header_lines = 1;
1599         my $in_commit_log = 0;          #Scanning lines before patch
1600
1601         my $non_utf8_charset = 0;
1602
1603         our @report = ();
1604         our $cnt_lines = 0;
1605         our $cnt_error = 0;
1606         our $cnt_warn = 0;
1607         our $cnt_chk = 0;
1608
1609         # Trace the real file/line as we go.
1610         my $realfile = '';
1611         my $realline = 0;
1612         my $realcnt = 0;
1613         my $here = '';
1614         my $in_comment = 0;
1615         my $comment_edge = 0;
1616         my $first_line = 0;
1617         my $p1_prefix = '';
1618
1619         my $prev_values = 'E';
1620
1621         # suppression flags
1622         my %suppress_ifbraces;
1623         my %suppress_whiletrailers;
1624         my %suppress_export;
1625         my $suppress_statement = 0;
1626
1627         my %signatures = ();
1628
1629         # Pre-scan the patch sanitizing the lines.
1630         # Pre-scan the patch looking for any __setup documentation.
1631         #
1632         my @setup_docs = ();
1633         my $setup_docs = 0;
1634
1635         my $camelcase_file_seeded = 0;
1636
1637         sanitise_line_reset();
1638         my $line;
1639         foreach my $rawline (@rawlines) {
1640                 $linenr++;
1641                 $line = $rawline;
1642
1643                 push(@fixed, $rawline) if ($fix);
1644
1645                 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1646                         $setup_docs = 0;
1647                         if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1648                                 $setup_docs = 1;
1649                         }
1650                         #next;
1651                 }
1652                 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1653                         $realline=$1-1;
1654                         if (defined $2) {
1655                                 $realcnt=$3+1;
1656                         } else {
1657                                 $realcnt=1+1;
1658                         }
1659                         $in_comment = 0;
1660
1661                         # Guestimate if this is a continuing comment.  Run
1662                         # the context looking for a comment "edge".  If this
1663                         # edge is a close comment then we must be in a comment
1664                         # at context start.
1665                         my $edge;
1666                         my $cnt = $realcnt;
1667                         for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1668                                 next if (defined $rawlines[$ln - 1] &&
1669                                          $rawlines[$ln - 1] =~ /^-/);
1670                                 $cnt--;
1671                                 #print "RAW<$rawlines[$ln - 1]>\n";
1672                                 last if (!defined $rawlines[$ln - 1]);
1673                                 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1674                                     $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1675                                         ($edge) = $1;
1676                                         last;
1677                                 }
1678                         }
1679                         if (defined $edge && $edge eq '*/') {
1680                                 $in_comment = 1;
1681                         }
1682
1683                         # Guestimate if this is a continuing comment.  If this
1684                         # is the start of a diff block and this line starts
1685                         # ' *' then it is very likely a comment.
1686                         if (!defined $edge &&
1687                             $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1688                         {
1689                                 $in_comment = 1;
1690                         }
1691
1692                         ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1693                         sanitise_line_reset($in_comment);
1694
1695                 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1696                         # Standardise the strings and chars within the input to
1697                         # simplify matching -- only bother with positive lines.
1698                         $line = sanitise_line($rawline);
1699                 }
1700                 push(@lines, $line);
1701
1702                 if ($realcnt > 1) {
1703                         $realcnt-- if ($line =~ /^(?:\+| |$)/);
1704                 } else {
1705                         $realcnt = 0;
1706                 }
1707
1708                 #print "==>$rawline\n";
1709                 #print "-->$line\n";
1710
1711                 if ($setup_docs && $line =~ /^\+/) {
1712                         push(@setup_docs, $line);
1713                 }
1714         }
1715
1716         $prefix = '';
1717
1718         $realcnt = 0;
1719         $linenr = 0;
1720         foreach my $line (@lines) {
1721                 $linenr++;
1722                 my $sline = $line;      #copy of $line
1723                 $sline =~ s/$;/ /g;     #with comments as spaces
1724
1725                 my $rawline = $rawlines[$linenr - 1];
1726
1727 #extract the line range in the file after the patch is applied
1728                 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1729                         $is_patch = 1;
1730                         $first_line = $linenr + 1;
1731                         $realline=$1-1;
1732                         if (defined $2) {
1733                                 $realcnt=$3+1;
1734                         } else {
1735                                 $realcnt=1+1;
1736                         }
1737                         annotate_reset();
1738                         $prev_values = 'E';
1739
1740                         %suppress_ifbraces = ();
1741                         %suppress_whiletrailers = ();
1742                         %suppress_export = ();
1743                         $suppress_statement = 0;
1744                         next;
1745
1746 # track the line number as we move through the hunk, note that
1747 # new versions of GNU diff omit the leading space on completely
1748 # blank context lines so we need to count that too.
1749                 } elsif ($line =~ /^( |\+|$)/) {
1750                         $realline++;
1751                         $realcnt-- if ($realcnt != 0);
1752
1753                         # Measure the line length and indent.
1754                         ($length, $indent) = line_stats($rawline);
1755
1756                         # Track the previous line.
1757                         ($prevline, $stashline) = ($stashline, $line);
1758                         ($previndent, $stashindent) = ($stashindent, $indent);
1759                         ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1760
1761                         #warn "line<$line>\n";
1762
1763                 } elsif ($realcnt == 1) {
1764                         $realcnt--;
1765                 }
1766
1767                 my $hunk_line = ($realcnt != 0);
1768
1769 #make up the handle for any error we report on this line
1770                 $prefix = "$filename:$realline: " if ($emacs && $file);
1771                 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1772
1773                 $here = "#$linenr: " if (!$file);
1774                 $here = "#$realline: " if ($file);
1775
1776                 # extract the filename as it passes
1777                 if ($line =~ /^diff --git.*?(\S+)$/) {
1778                         $realfile = $1;
1779                         $realfile =~ s@^([^/]*)/@@ if (!$file);
1780                         $in_commit_log = 0;
1781                 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1782                         $realfile = $1;
1783                         $realfile =~ s@^([^/]*)/@@ if (!$file);
1784                         $in_commit_log = 0;
1785
1786                         $p1_prefix = $1;
1787                         if (!$file && $tree && $p1_prefix ne '' &&
1788                             -e "$root/$p1_prefix") {
1789                                 WARN("PATCH_PREFIX",
1790                                      "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1791                         }
1792
1793                         if ($realfile =~ m@^include/asm/@) {
1794                                 ERROR("MODIFIED_INCLUDE_ASM",
1795                                       "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1796                         }
1797                         next;
1798                 }
1799
1800                 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1801
1802                 my $hereline = "$here\n$rawline\n";
1803                 my $herecurr = "$here\n$rawline\n";
1804                 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1805
1806                 $cnt_lines++ if ($realcnt != 0);
1807
1808 # Check for incorrect file permissions
1809                 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1810                         my $permhere = $here . "FILE: $realfile\n";
1811                         if ($realfile !~ m@scripts/@ &&
1812                             $realfile !~ /\.(py|pl|awk|sh)$/) {
1813                                 ERROR("EXECUTE_PERMISSIONS",
1814                                       "do not set execute permissions for source files\n" . $permhere);
1815                         }
1816                 }
1817
1818 # Check the patch for a signoff:
1819                 if ($line =~ /^\s*signed-off-by:/i) {
1820                         $signoff++;
1821                         $in_commit_log = 0;
1822                 }
1823
1824 # Check signature styles
1825                 if (!$in_header_lines &&
1826                     $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
1827                         my $space_before = $1;
1828                         my $sign_off = $2;
1829                         my $space_after = $3;
1830                         my $email = $4;
1831                         my $ucfirst_sign_off = ucfirst(lc($sign_off));
1832
1833                         if ($sign_off !~ /$signature_tags/) {
1834                                 WARN("BAD_SIGN_OFF",
1835                                      "Non-standard signature: $sign_off\n" . $herecurr);
1836                         }
1837                         if (defined $space_before && $space_before ne "") {
1838                                 if (WARN("BAD_SIGN_OFF",
1839                                          "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
1840                                     $fix) {
1841                                         $fixed[$linenr - 1] =
1842                                             "$ucfirst_sign_off $email";
1843                                 }
1844                         }
1845                         if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1846                                 if (WARN("BAD_SIGN_OFF",
1847                                          "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
1848                                     $fix) {
1849                                         $fixed[$linenr - 1] =
1850                                             "$ucfirst_sign_off $email";
1851                                 }
1852
1853                         }
1854                         if (!defined $space_after || $space_after ne " ") {
1855                                 if (WARN("BAD_SIGN_OFF",
1856                                          "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
1857                                     $fix) {
1858                                         $fixed[$linenr - 1] =
1859                                             "$ucfirst_sign_off $email";
1860                                 }
1861                         }
1862
1863                         my ($email_name, $email_address, $comment) = parse_email($email);
1864                         my $suggested_email = format_email(($email_name, $email_address));
1865                         if ($suggested_email eq "") {
1866                                 ERROR("BAD_SIGN_OFF",
1867                                       "Unrecognized email address: '$email'\n" . $herecurr);
1868                         } else {
1869                                 my $dequoted = $suggested_email;
1870                                 $dequoted =~ s/^"//;
1871                                 $dequoted =~ s/" </ </;
1872                                 # Don't force email to have quotes
1873                                 # Allow just an angle bracketed address
1874                                 if ("$dequoted$comment" ne $email &&
1875                                     "<$email_address>$comment" ne $email &&
1876                                     "$suggested_email$comment" ne $email) {
1877                                         WARN("BAD_SIGN_OFF",
1878                                              "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1879                                 }
1880                         }
1881
1882 # Check for duplicate signatures
1883                         my $sig_nospace = $line;
1884                         $sig_nospace =~ s/\s//g;
1885                         $sig_nospace = lc($sig_nospace);
1886                         if (defined $signatures{$sig_nospace}) {
1887                                 WARN("BAD_SIGN_OFF",
1888                                      "Duplicate signature\n" . $herecurr);
1889                         } else {
1890                                 $signatures{$sig_nospace} = 1;
1891                         }
1892                 }
1893
1894 # Check for wrappage within a valid hunk of the file
1895                 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1896                         ERROR("CORRUPTED_PATCH",
1897                               "patch seems to be corrupt (line wrapped?)\n" .
1898                                 $herecurr) if (!$emitted_corrupt++);
1899                 }
1900
1901 # Check for absolute kernel paths.
1902                 if ($tree) {
1903                         while ($line =~ m{(?:^|\s)(/\S*)}g) {
1904                                 my $file = $1;
1905
1906                                 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1907                                     check_absolute_file($1, $herecurr)) {
1908                                         #
1909                                 } else {
1910                                         check_absolute_file($file, $herecurr);
1911                                 }
1912                         }
1913                 }
1914
1915 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1916                 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1917                     $rawline !~ m/^$UTF8*$/) {
1918                         my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1919
1920                         my $blank = copy_spacing($rawline);
1921                         my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1922                         my $hereptr = "$hereline$ptr\n";
1923
1924                         CHK("INVALID_UTF8",
1925                             "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1926                 }
1927
1928 # Check if it's the start of a commit log
1929 # (not a header line and we haven't seen the patch filename)
1930                 if ($in_header_lines && $realfile =~ /^$/ &&
1931                     $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
1932                         $in_header_lines = 0;
1933                         $in_commit_log = 1;
1934                 }
1935
1936 # Check if there is UTF-8 in a commit log when a mail header has explicitly
1937 # declined it, i.e defined some charset where it is missing.
1938                 if ($in_header_lines &&
1939                     $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
1940                     $1 !~ /utf-8/i) {
1941                         $non_utf8_charset = 1;
1942                 }
1943
1944                 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
1945                     $rawline =~ /$NON_ASCII_UTF8/) {
1946                         WARN("UTF8_BEFORE_PATCH",
1947                             "8-bit UTF-8 used in possible commit log\n" . $herecurr);
1948                 }
1949
1950 # ignore non-hunk lines and lines being removed
1951                 next if (!$hunk_line || $line =~ /^-/);
1952
1953 #trailing whitespace
1954                 if ($line =~ /^\+.*\015/) {
1955                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1956                         if (ERROR("DOS_LINE_ENDINGS",
1957                                   "DOS line endings\n" . $herevet) &&
1958                             $fix) {
1959                                 $fixed[$linenr - 1] =~ s/[\s\015]+$//;
1960                         }
1961                 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1962                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1963                         if (ERROR("TRAILING_WHITESPACE",
1964                                   "trailing whitespace\n" . $herevet) &&
1965                             $fix) {
1966                                 $fixed[$linenr - 1] =~ s/\s+$//;
1967                         }
1968
1969                         $rpt_cleaners = 1;
1970                 }
1971
1972 # Check for FSF mailing addresses.
1973                 if ($rawline =~ /\bwrite to the Free/i ||
1974                     $rawline =~ /\b59\s+Temple\s+Pl/i ||
1975                     $rawline =~ /\b51\s+Franklin\s+St/i) {
1976                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1977                         my $msg_type = \&ERROR;
1978                         $msg_type = \&CHK if ($file);
1979                         &{$msg_type}("FSF_MAILING_ADDRESS",
1980                                      "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)
1981                 }
1982
1983 # check for Kconfig help text having a real description
1984 # Only applies when adding the entry originally, after that we do not have
1985 # sufficient context to determine whether it is indeed long enough.
1986                 if ($realfile =~ /Kconfig/ &&
1987                     $line =~ /.\s*config\s+/) {
1988                         my $length = 0;
1989                         my $cnt = $realcnt;
1990                         my $ln = $linenr + 1;
1991                         my $f;
1992                         my $is_start = 0;
1993                         my $is_end = 0;
1994                         for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
1995                                 $f = $lines[$ln - 1];
1996                                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
1997                                 $is_end = $lines[$ln - 1] =~ /^\+/;
1998
1999                                 next if ($f =~ /^-/);
2000
2001                                 if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
2002                                         $is_start = 1;
2003                                 } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
2004                                         $length = -1;
2005                                 }
2006
2007                                 $f =~ s/^.//;
2008                                 $f =~ s/#.*//;
2009                                 $f =~ s/^\s+//;
2010                                 next if ($f =~ /^$/);
2011                                 if ($f =~ /^\s*config\s/) {
2012                                         $is_end = 1;
2013                                         last;
2014                                 }
2015                                 $length++;
2016                         }
2017                         WARN("CONFIG_DESCRIPTION",
2018                              "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2019                         #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2020                 }
2021
2022 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2023                 if ($realfile =~ /Kconfig/ &&
2024                     $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2025                         WARN("CONFIG_EXPERIMENTAL",
2026                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2027                 }
2028
2029                 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2030                     ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2031                         my $flag = $1;
2032                         my $replacement = {
2033                                 'EXTRA_AFLAGS' =>   'asflags-y',
2034                                 'EXTRA_CFLAGS' =>   'ccflags-y',
2035                                 'EXTRA_CPPFLAGS' => 'cppflags-y',
2036                                 'EXTRA_LDFLAGS' =>  'ldflags-y',
2037                         };
2038
2039                         WARN("DEPRECATED_VARIABLE",
2040                              "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2041                 }
2042
2043 # check for DT compatible documentation
2044                 if (defined $root && $realfile =~ /\.dts/ &&
2045                     $rawline =~ /^\+\s*compatible\s*=/) {
2046                         my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2047
2048                         foreach my $compat (@compats) {
2049                                 my $compat2 = $compat;
2050                                 my $dt_path =  $root . "/Documentation/devicetree/bindings/";
2051                                 $compat2 =~ s/\,[a-z]*\-/\,<\.\*>\-/;
2052                                 `grep -Erq "$compat|$compat2" $dt_path`;
2053                                 if ( $? >> 8 ) {
2054                                         WARN("UNDOCUMENTED_DT_STRING",
2055                                              "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2056                                 }
2057
2058                                 my $vendor = $compat;
2059                                 my $vendor_path = $dt_path . "vendor-prefixes.txt";
2060                                 next if (! -f $vendor_path);
2061                                 $vendor =~ s/^([a-zA-Z0-9]+)\,.*/$1/;
2062                                 `grep -Eq "$vendor" $vendor_path`;
2063                                 if ( $? >> 8 ) {
2064                                         WARN("UNDOCUMENTED_DT_STRING",
2065                                              "DT compatible string vendor \"$vendor\" appears un-documented -- check $vendor_path\n" . $herecurr);
2066                                 }
2067                         }
2068                 }
2069
2070 # check we are in a valid source file if not then ignore this hunk
2071                 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2072
2073 #line length limit
2074                 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2075                     $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2076                     !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2077                     $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2078                     $length > $max_line_length)
2079                 {
2080                         WARN("LONG_LINE",
2081                              "line over $max_line_length characters\n" . $herecurr);
2082                 }
2083
2084 # Check for user-visible strings broken across lines, which breaks the ability
2085 # to grep for the string.  Make exceptions when the previous string ends in a
2086 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2087 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2088                 if ($line =~ /^\+\s*"/ &&
2089                     $prevline =~ /"\s*$/ &&
2090                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2091                         WARN("SPLIT_STRING",
2092                              "quoted string split across lines\n" . $hereprev);
2093                 }
2094
2095 # check for spaces before a quoted newline
2096                 if ($rawline =~ /^.*\".*\s\\n/) {
2097                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2098                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2099                             $fix) {
2100                                 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2101                         }
2102
2103                 }
2104
2105 # check for adding lines without a newline.
2106                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2107                         WARN("MISSING_EOF_NEWLINE",
2108                              "adding a line without newline at end of file\n" . $herecurr);
2109                 }
2110
2111 # Blackfin: use hi/lo macros
2112                 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2113                         if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2114                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2115                                 ERROR("LO_MACRO",
2116                                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2117                         }
2118                         if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2119                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2120                                 ERROR("HI_MACRO",
2121                                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2122                         }
2123                 }
2124
2125 # check we are in a valid source file C or perl if not then ignore this hunk
2126                 next if ($realfile !~ /\.(h|c|pl)$/);
2127
2128 # at the beginning of a line any tabs must come first and anything
2129 # more than 8 must use tabs.
2130                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2131                     $rawline =~ /^\+\s*        \s*/) {
2132                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2133                         $rpt_cleaners = 1;
2134                         if (ERROR("CODE_INDENT",
2135                                   "code indent should use tabs where possible\n" . $herevet) &&
2136                             $fix) {
2137                                 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2138                         }
2139                 }
2140
2141 # check for space before tabs.
2142                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2143                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2144                         if (WARN("SPACE_BEFORE_TAB",
2145                                 "please, no space before tabs\n" . $herevet) &&
2146                             $fix) {
2147                                 while ($fixed[$linenr - 1] =~
2148                                            s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2149                                 while ($fixed[$linenr - 1] =~
2150                                            s/(^\+.*) +\t/$1\t/) {}
2151                         }
2152                 }
2153
2154 # check for && or || at the start of a line
2155                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2156                         CHK("LOGICAL_CONTINUATIONS",
2157                             "Logical continuations should be on the previous line\n" . $hereprev);
2158                 }
2159
2160 # check multi-line statement indentation matches previous line
2161                 if ($^V && $^V ge 5.10.0 &&
2162                     $prevline =~ /^\+(\t*)(if \(|$Ident\().*(\&\&|\|\||,)\s*$/) {
2163                         $prevline =~ /^\+(\t*)(.*)$/;
2164                         my $oldindent = $1;
2165                         my $rest = $2;
2166
2167                         my $pos = pos_last_openparen($rest);
2168                         if ($pos >= 0) {
2169                                 $line =~ /^(\+| )([ \t]*)/;
2170                                 my $newindent = $2;
2171
2172                                 my $goodtabindent = $oldindent .
2173                                         "\t" x ($pos / 8) .
2174                                         " "  x ($pos % 8);
2175                                 my $goodspaceindent = $oldindent . " "  x $pos;
2176
2177                                 if ($newindent ne $goodtabindent &&
2178                                     $newindent ne $goodspaceindent) {
2179
2180                                         if (CHK("PARENTHESIS_ALIGNMENT",
2181                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
2182                                             $fix && $line =~ /^\+/) {
2183                                                 $fixed[$linenr - 1] =~
2184                                                     s/^\+[ \t]*/\+$goodtabindent/;
2185                                         }
2186                                 }
2187                         }
2188                 }
2189
2190                 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
2191                         if (CHK("SPACING",
2192                                 "No space is necessary after a cast\n" . $hereprev) &&
2193                             $fix) {
2194                                 $fixed[$linenr - 1] =~
2195                                     s/^(\+.*\*[ \t]*\))[ \t]+/$1/;
2196                         }
2197                 }
2198
2199                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2200                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2201                     $rawline =~ /^\+[ \t]*\*/) {
2202                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2203                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2204                 }
2205
2206                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2207                     $prevrawline =~ /^\+[ \t]*\/\*/ &&          #starting /*
2208                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
2209                     $rawline =~ /^\+/ &&                        #line is new
2210                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
2211                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2212                              "networking block comments start with * on subsequent lines\n" . $hereprev);
2213                 }
2214
2215                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2216                     $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
2217                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
2218                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
2219                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
2220                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2221                              "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2222                 }
2223
2224 # check for spaces at the beginning of a line.
2225 # Exceptions:
2226 #  1) within comments
2227 #  2) indented preprocessor commands
2228 #  3) hanging labels
2229                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2230                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2231                         if (WARN("LEADING_SPACE",
2232                                  "please, no spaces at the start of a line\n" . $herevet) &&
2233                             $fix) {
2234                                 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2235                         }
2236                 }
2237
2238 # check we are in a valid C source file if not then ignore this hunk
2239                 next if ($realfile !~ /\.(h|c)$/);
2240
2241 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2242                 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2243                         WARN("CONFIG_EXPERIMENTAL",
2244                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2245                 }
2246
2247 # check for RCS/CVS revision markers
2248                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2249                         WARN("CVS_KEYWORD",
2250                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2251                 }
2252
2253 # Blackfin: don't use __builtin_bfin_[cs]sync
2254                 if ($line =~ /__builtin_bfin_csync/) {
2255                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2256                         ERROR("CSYNC",
2257                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2258                 }
2259                 if ($line =~ /__builtin_bfin_ssync/) {
2260                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2261                         ERROR("SSYNC",
2262                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2263                 }
2264
2265 # check for old HOTPLUG __dev<foo> section markings
2266                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2267                         WARN("HOTPLUG_SECTION",
2268                              "Using $1 is unnecessary\n" . $herecurr);
2269                 }
2270
2271 # Check for potential 'bare' types
2272                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2273                     $realline_next);
2274 #print "LINE<$line>\n";
2275                 if ($linenr >= $suppress_statement &&
2276                     $realcnt && $sline =~ /.\s*\S/) {
2277                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2278                                 ctx_statement_block($linenr, $realcnt, 0);
2279                         $stat =~ s/\n./\n /g;
2280                         $cond =~ s/\n./\n /g;
2281
2282 #print "linenr<$linenr> <$stat>\n";
2283                         # If this statement has no statement boundaries within
2284                         # it there is no point in retrying a statement scan
2285                         # until we hit end of it.
2286                         my $frag = $stat; $frag =~ s/;+\s*$//;
2287                         if ($frag !~ /(?:{|;)/) {
2288 #print "skip<$line_nr_next>\n";
2289                                 $suppress_statement = $line_nr_next;
2290                         }
2291
2292                         # Find the real next line.
2293                         $realline_next = $line_nr_next;
2294                         if (defined $realline_next &&
2295                             (!defined $lines[$realline_next - 1] ||
2296                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2297                                 $realline_next++;
2298                         }
2299
2300                         my $s = $stat;
2301                         $s =~ s/{.*$//s;
2302
2303                         # Ignore goto labels.
2304                         if ($s =~ /$Ident:\*$/s) {
2305
2306                         # Ignore functions being called
2307                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2308
2309                         } elsif ($s =~ /^.\s*else\b/s) {
2310
2311                         # declarations always start with types
2312                         } 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) {
2313                                 my $type = $1;
2314                                 $type =~ s/\s+/ /g;
2315                                 possible($type, "A:" . $s);
2316
2317                         # definitions in global scope can only start with types
2318                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2319                                 possible($1, "B:" . $s);
2320                         }
2321
2322                         # any (foo ... *) is a pointer cast, and foo is a type
2323                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2324                                 possible($1, "C:" . $s);
2325                         }
2326
2327                         # Check for any sort of function declaration.
2328                         # int foo(something bar, other baz);
2329                         # void (*store_gdt)(x86_descr_ptr *);
2330                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2331                                 my ($name_len) = length($1);
2332
2333                                 my $ctx = $s;
2334                                 substr($ctx, 0, $name_len + 1, '');
2335                                 $ctx =~ s/\)[^\)]*$//;
2336
2337                                 for my $arg (split(/\s*,\s*/, $ctx)) {
2338                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2339
2340                                                 possible($1, "D:" . $s);
2341                                         }
2342                                 }
2343                         }
2344
2345                 }
2346
2347 #
2348 # Checks which may be anchored in the context.
2349 #
2350
2351 # Check for switch () and associated case and default
2352 # statements should be at the same indent.
2353                 if ($line=~/\bswitch\s*\(.*\)/) {
2354                         my $err = '';
2355                         my $sep = '';
2356                         my @ctx = ctx_block_outer($linenr, $realcnt);
2357                         shift(@ctx);
2358                         for my $ctx (@ctx) {
2359                                 my ($clen, $cindent) = line_stats($ctx);
2360                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2361                                                         $indent != $cindent) {
2362                                         $err .= "$sep$ctx\n";
2363                                         $sep = '';
2364                                 } else {
2365                                         $sep = "[...]\n";
2366                                 }
2367                         }
2368                         if ($err ne '') {
2369                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
2370                                       "switch and case should be at the same indent\n$hereline$err");
2371                         }
2372                 }
2373
2374 # if/while/etc brace do not go on next line, unless defining a do while loop,
2375 # or if that brace on the next line is for something else
2376                 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2377                         my $pre_ctx = "$1$2";
2378
2379                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2380
2381                         if ($line =~ /^\+\t{6,}/) {
2382                                 WARN("DEEP_INDENTATION",
2383                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
2384                         }
2385
2386                         my $ctx_cnt = $realcnt - $#ctx - 1;
2387                         my $ctx = join("\n", @ctx);
2388
2389                         my $ctx_ln = $linenr;
2390                         my $ctx_skip = $realcnt;
2391
2392                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2393                                         defined $lines[$ctx_ln - 1] &&
2394                                         $lines[$ctx_ln - 1] =~ /^-/)) {
2395                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2396                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2397                                 $ctx_ln++;
2398                         }
2399
2400                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2401                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2402
2403                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2404                                 ERROR("OPEN_BRACE",
2405                                       "that open brace { should be on the previous line\n" .
2406                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2407                         }
2408                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2409                             $ctx =~ /\)\s*\;\s*$/ &&
2410                             defined $lines[$ctx_ln - 1])
2411                         {
2412                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2413                                 if ($nindent > $indent) {
2414                                         WARN("TRAILING_SEMICOLON",
2415                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
2416                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2417                                 }
2418                         }
2419                 }
2420
2421 # Check relative indent for conditionals and blocks.
2422                 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2423                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2424                                 ctx_statement_block($linenr, $realcnt, 0)
2425                                         if (!defined $stat);
2426                         my ($s, $c) = ($stat, $cond);
2427
2428                         substr($s, 0, length($c), '');
2429
2430                         # Make sure we remove the line prefixes as we have
2431                         # none on the first line, and are going to readd them
2432                         # where necessary.
2433                         $s =~ s/\n./\n/gs;
2434
2435                         # Find out how long the conditional actually is.
2436                         my @newlines = ($c =~ /\n/gs);
2437                         my $cond_lines = 1 + $#newlines;
2438
2439                         # We want to check the first line inside the block
2440                         # starting at the end of the conditional, so remove:
2441                         #  1) any blank line termination
2442                         #  2) any opening brace { on end of the line
2443                         #  3) any do (...) {
2444                         my $continuation = 0;
2445                         my $check = 0;
2446                         $s =~ s/^.*\bdo\b//;
2447                         $s =~ s/^\s*{//;
2448                         if ($s =~ s/^\s*\\//) {
2449                                 $continuation = 1;
2450                         }
2451                         if ($s =~ s/^\s*?\n//) {
2452                                 $check = 1;
2453                                 $cond_lines++;
2454                         }
2455
2456                         # Also ignore a loop construct at the end of a
2457                         # preprocessor statement.
2458                         if (($prevline =~ /^.\s*#\s*define\s/ ||
2459                             $prevline =~ /\\\s*$/) && $continuation == 0) {
2460                                 $check = 0;
2461                         }
2462
2463                         my $cond_ptr = -1;
2464                         $continuation = 0;
2465                         while ($cond_ptr != $cond_lines) {
2466                                 $cond_ptr = $cond_lines;
2467
2468                                 # If we see an #else/#elif then the code
2469                                 # is not linear.
2470                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2471                                         $check = 0;
2472                                 }
2473
2474                                 # Ignore:
2475                                 #  1) blank lines, they should be at 0,
2476                                 #  2) preprocessor lines, and
2477                                 #  3) labels.
2478                                 if ($continuation ||
2479                                     $s =~ /^\s*?\n/ ||
2480                                     $s =~ /^\s*#\s*?/ ||
2481                                     $s =~ /^\s*$Ident\s*:/) {
2482                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2483                                         if ($s =~ s/^.*?\n//) {
2484                                                 $cond_lines++;
2485                                         }
2486                                 }
2487                         }
2488
2489                         my (undef, $sindent) = line_stats("+" . $s);
2490                         my $stat_real = raw_line($linenr, $cond_lines);
2491
2492                         # Check if either of these lines are modified, else
2493                         # this is not this patch's fault.
2494                         if (!defined($stat_real) ||
2495                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2496                                 $check = 0;
2497                         }
2498                         if (defined($stat_real) && $cond_lines > 1) {
2499                                 $stat_real = "[...]\n$stat_real";
2500                         }
2501
2502                         #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";
2503
2504                         if ($check && (($sindent % 8) != 0 ||
2505                             ($sindent <= $indent && $s ne ''))) {
2506                                 WARN("SUSPECT_CODE_INDENT",
2507                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2508                         }
2509                 }
2510
2511                 # Track the 'values' across context and added lines.
2512                 my $opline = $line; $opline =~ s/^./ /;
2513                 my ($curr_values, $curr_vars) =
2514                                 annotate_values($opline . "\n", $prev_values);
2515                 $curr_values = $prev_values . $curr_values;
2516                 if ($dbg_values) {
2517                         my $outline = $opline; $outline =~ s/\t/ /g;
2518                         print "$linenr > .$outline\n";
2519                         print "$linenr > $curr_values\n";
2520                         print "$linenr >  $curr_vars\n";
2521                 }
2522                 $prev_values = substr($curr_values, -1);
2523
2524 #ignore lines not being added
2525                 next if ($line =~ /^[^\+]/);
2526
2527 # TEST: allow direct testing of the type matcher.
2528                 if ($dbg_type) {
2529                         if ($line =~ /^.\s*$Declare\s*$/) {
2530                                 ERROR("TEST_TYPE",
2531                                       "TEST: is type\n" . $herecurr);
2532                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2533                                 ERROR("TEST_NOT_TYPE",
2534                                       "TEST: is not type ($1 is)\n". $herecurr);
2535                         }
2536                         next;
2537                 }
2538 # TEST: allow direct testing of the attribute matcher.
2539                 if ($dbg_attr) {
2540                         if ($line =~ /^.\s*$Modifier\s*$/) {
2541                                 ERROR("TEST_ATTR",
2542                                       "TEST: is attr\n" . $herecurr);
2543                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2544                                 ERROR("TEST_NOT_ATTR",
2545                                       "TEST: is not attr ($1 is)\n". $herecurr);
2546                         }
2547                         next;
2548                 }
2549
2550 # check for initialisation to aggregates open brace on the next line
2551                 if ($line =~ /^.\s*{/ &&
2552                     $prevline =~ /(?:^|[^=])=\s*$/) {
2553                         ERROR("OPEN_BRACE",
2554                               "that open brace { should be on the previous line\n" . $hereprev);
2555                 }
2556
2557 #
2558 # Checks which are anchored on the added line.
2559 #
2560
2561 # check for malformed paths in #include statements (uses RAW line)
2562                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2563                         my $path = $1;
2564                         if ($path =~ m{//}) {
2565                                 ERROR("MALFORMED_INCLUDE",
2566                                       "malformed #include filename\n" . $herecurr);
2567                         }
2568                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2569                                 ERROR("UAPI_INCLUDE",
2570                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2571                         }
2572                 }
2573
2574 # no C99 // comments
2575                 if ($line =~ m{//}) {
2576                         if (ERROR("C99_COMMENTS",
2577                                   "do not use C99 // comments\n" . $herecurr) &&
2578                             $fix) {
2579                                 my $line = $fixed[$linenr - 1];
2580                                 if ($line =~ /\/\/(.*)$/) {
2581                                         my $comment = trim($1);
2582                                         $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2583                                 }
2584                         }
2585                 }
2586                 # Remove C99 comments.
2587                 $line =~ s@//.*@@;
2588                 $opline =~ s@//.*@@;
2589
2590 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2591 # the whole statement.
2592 #print "APW <$lines[$realline_next - 1]>\n";
2593                 if (defined $realline_next &&
2594                     exists $lines[$realline_next - 1] &&
2595                     !defined $suppress_export{$realline_next} &&
2596                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2597                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2598                         # Handle definitions which produce identifiers with
2599                         # a prefix:
2600                         #   XXX(foo);
2601                         #   EXPORT_SYMBOL(something_foo);
2602                         my $name = $1;
2603                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
2604                             $name =~ /^${Ident}_$2/) {
2605 #print "FOO C name<$name>\n";
2606                                 $suppress_export{$realline_next} = 1;
2607
2608                         } elsif ($stat !~ /(?:
2609                                 \n.}\s*$|
2610                                 ^.DEFINE_$Ident\(\Q$name\E\)|
2611                                 ^.DECLARE_$Ident\(\Q$name\E\)|
2612                                 ^.LIST_HEAD\(\Q$name\E\)|
2613                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2614                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2615                             )/x) {
2616 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2617                                 $suppress_export{$realline_next} = 2;
2618                         } else {
2619                                 $suppress_export{$realline_next} = 1;
2620                         }
2621                 }
2622                 if (!defined $suppress_export{$linenr} &&
2623                     $prevline =~ /^.\s*$/ &&
2624                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2625                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2626 #print "FOO B <$lines[$linenr - 1]>\n";
2627                         $suppress_export{$linenr} = 2;
2628                 }
2629                 if (defined $suppress_export{$linenr} &&
2630                     $suppress_export{$linenr} == 2) {
2631                         WARN("EXPORT_SYMBOL",
2632                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2633                 }
2634
2635 # check for global initialisers.
2636                 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2637                         if (ERROR("GLOBAL_INITIALISERS",
2638                                   "do not initialise globals to 0 or NULL\n" .
2639                                       $herecurr) &&
2640                             $fix) {
2641                                 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2642                         }
2643                 }
2644 # check for static initialisers.
2645                 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2646                         if (ERROR("INITIALISED_STATIC",
2647                                   "do not initialise statics to 0 or NULL\n" .
2648                                       $herecurr) &&
2649                             $fix) {
2650                                 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2651                         }
2652                 }
2653
2654 # check for static const char * arrays.
2655                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2656                         WARN("STATIC_CONST_CHAR_ARRAY",
2657                              "static const char * array should probably be static const char * const\n" .
2658                                 $herecurr);
2659                }
2660
2661 # check for static char foo[] = "bar" declarations.
2662                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2663                         WARN("STATIC_CONST_CHAR_ARRAY",
2664                              "static char array declaration should probably be static const char\n" .
2665                                 $herecurr);
2666                }
2667
2668 # check for function declarations without arguments like "int foo()"
2669                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2670                         if (ERROR("FUNCTION_WITHOUT_ARGS",
2671                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2672                             $fix) {
2673                                 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2674                         }
2675                 }
2676
2677 # check for uses of DEFINE_PCI_DEVICE_TABLE
2678                 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2679                         if (WARN("DEFINE_PCI_DEVICE_TABLE",
2680                                  "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2681                             $fix) {
2682                                 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2683                         }
2684                 }
2685
2686 # check for new typedefs, only function parameters and sparse annotations
2687 # make sense.
2688                 if ($line =~ /\btypedef\s/ &&
2689                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2690                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2691                     $line !~ /\b$typeTypedefs\b/ &&
2692                     $line !~ /\b__bitwise(?:__|)\b/) {
2693                         WARN("NEW_TYPEDEFS",
2694                              "do not add new typedefs\n" . $herecurr);
2695                 }
2696
2697 # * goes on variable not on type
2698                 # (char*[ const])
2699                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2700                         #print "AA<$1>\n";
2701                         my ($ident, $from, $to) = ($1, $2, $2);
2702
2703                         # Should start with a space.
2704                         $to =~ s/^(\S)/ $1/;
2705                         # Should not end with a space.
2706                         $to =~ s/\s+$//;
2707                         # '*'s should not have spaces between.
2708                         while ($to =~ s/\*\s+\*/\*\*/) {
2709                         }
2710
2711 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
2712                         if ($from ne $to) {
2713                                 if (ERROR("POINTER_LOCATION",
2714                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
2715                                     $fix) {
2716                                         my $sub_from = $ident;
2717                                         my $sub_to = $ident;
2718                                         $sub_to =~ s/\Q$from\E/$to/;
2719                                         $fixed[$linenr - 1] =~
2720                                             s@\Q$sub_from\E@$sub_to@;
2721                                 }
2722                         }
2723                 }
2724                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2725                         #print "BB<$1>\n";
2726                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
2727
2728                         # Should start with a space.
2729                         $to =~ s/^(\S)/ $1/;
2730                         # Should not end with a space.
2731                         $to =~ s/\s+$//;
2732                         # '*'s should not have spaces between.
2733                         while ($to =~ s/\*\s+\*/\*\*/) {
2734                         }
2735                         # Modifiers should have spaces.
2736                         $to =~ s/(\b$Modifier$)/$1 /;
2737
2738 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
2739                         if ($from ne $to && $ident !~ /^$Modifier$/) {
2740                                 if (ERROR("POINTER_LOCATION",
2741                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
2742                                     $fix) {
2743
2744                                         my $sub_from = $match;
2745                                         my $sub_to = $match;
2746                                         $sub_to =~ s/\Q$from\E/$to/;
2747                                         $fixed[$linenr - 1] =~
2748                                             s@\Q$sub_from\E@$sub_to@;
2749                                 }
2750                         }
2751                 }
2752
2753 # # no BUG() or BUG_ON()
2754 #               if ($line =~ /\b(BUG|BUG_ON)\b/) {
2755 #                       print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2756 #                       print "$herecurr";
2757 #                       $clean = 0;
2758 #               }
2759
2760                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2761                         WARN("LINUX_VERSION_CODE",
2762                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2763                 }
2764
2765 # check for uses of printk_ratelimit
2766                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2767                         WARN("PRINTK_RATELIMITED",
2768 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2769                 }
2770
2771 # printk should use KERN_* levels.  Note that follow on printk's on the
2772 # same line do not need a level, so we use the current block context
2773 # to try and find and validate the current printk.  In summary the current
2774 # printk includes all preceding printk's which have no newline on the end.
2775 # we assume the first bad printk is the one to report.
2776                 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2777                         my $ok = 0;
2778                         for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2779                                 #print "CHECK<$lines[$ln - 1]\n";
2780                                 # we have a preceding printk if it ends
2781                                 # with "\n" ignore it, else it is to blame
2782                                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2783                                         if ($rawlines[$ln - 1] !~ m{\\n"}) {
2784                                                 $ok = 1;
2785                                         }
2786                                         last;
2787                                 }
2788                         }
2789                         if ($ok == 0) {
2790                                 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2791                                      "printk() should include KERN_ facility level\n" . $herecurr);
2792                         }
2793                 }
2794
2795                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2796                         my $orig = $1;
2797                         my $level = lc($orig);
2798                         $level = "warn" if ($level eq "warning");
2799                         my $level2 = $level;
2800                         $level2 = "dbg" if ($level eq "debug");
2801                         WARN("PREFER_PR_LEVEL",
2802                              "Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
2803                 }
2804
2805                 if ($line =~ /\bpr_warning\s*\(/) {
2806                         if (WARN("PREFER_PR_LEVEL",
2807                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2808                             $fix) {
2809                                 $fixed[$linenr - 1] =~
2810                                     s/\bpr_warning\b/pr_warn/;
2811                         }
2812                 }
2813
2814                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2815                         my $orig = $1;
2816                         my $level = lc($orig);
2817                         $level = "warn" if ($level eq "warning");
2818                         $level = "dbg" if ($level eq "debug");
2819                         WARN("PREFER_DEV_LEVEL",
2820                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2821                 }
2822
2823 # function brace can't be on same line, except for #defines of do while,
2824 # or if closed on same line
2825                 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2826                     !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2827                         ERROR("OPEN_BRACE",
2828                               "open brace '{' following function declarations go on the next line\n" . $herecurr);
2829                 }
2830
2831 # open braces for enum, union and struct go on the same line.
2832                 if ($line =~ /^.\s*{/ &&
2833                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2834                         ERROR("OPEN_BRACE",
2835                               "open brace '{' following $1 go on the same line\n" . $hereprev);
2836                 }
2837
2838 # missing space after union, struct or enum definition
2839                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2840                         if (WARN("SPACING",
2841                                  "missing space after $1 definition\n" . $herecurr) &&
2842                             $fix) {
2843                                 $fixed[$linenr - 1] =~
2844                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
2845                         }
2846                 }
2847
2848 # Function pointer declarations
2849 # check spacing between type, funcptr, and args
2850 # canonical declaration is "type (*funcptr)(args...)"
2851                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
2852                         my $declare = $1;
2853                         my $pre_pointer_space = $2;
2854                         my $post_pointer_space = $3;
2855                         my $funcname = $4;
2856                         my $post_funcname_space = $5;
2857                         my $pre_args_space = $6;
2858
2859 # the $Declare variable will capture all spaces after the type
2860 # so check it for a missing trailing missing space but pointer return types
2861 # don't need a space so don't warn for those.
2862                         my $post_declare_space = "";
2863                         if ($declare =~ /(\s+)$/) {
2864                                 $post_declare_space = $1;
2865                                 $declare = rtrim($declare);
2866                         }
2867                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
2868                                 WARN("SPACING",
2869                                      "missing space after return type\n" . $herecurr);
2870                                 $post_declare_space = " ";
2871                         }
2872
2873 # unnecessary space "type  (*funcptr)(args...)"
2874 # This test is not currently implemented because these declarations are
2875 # equivalent to
2876 #       int  foo(int bar, ...)
2877 # and this is form shouldn't/doesn't generate a checkpatch warning.
2878 #
2879 #                       elsif ($declare =~ /\s{2,}$/) {
2880 #                               WARN("SPACING",
2881 #                                    "Multiple spaces after return type\n" . $herecurr);
2882 #                       }
2883
2884 # unnecessary space "type ( *funcptr)(args...)"
2885                         if (defined $pre_pointer_space &&
2886                             $pre_pointer_space =~ /^\s/) {
2887                                 WARN("SPACING",
2888                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
2889                         }
2890
2891 # unnecessary space "type (* funcptr)(args...)"
2892                         if (defined $post_pointer_space &&
2893                             $post_pointer_space =~ /^\s/) {
2894                                 WARN("SPACING",
2895                                      "Unnecessary space before function pointer name\n" . $herecurr);
2896                         }
2897
2898 # unnecessary space "type (*funcptr )(args...)"
2899                         if (defined $post_funcname_space &&
2900                             $post_funcname_space =~ /^\s/) {
2901                                 WARN("SPACING",
2902                                      "Unnecessary space after function pointer name\n" . $herecurr);
2903                         }
2904
2905 # unnecessary space "type (*funcptr) (args...)"
2906                         if (defined $pre_args_space &&
2907                             $pre_args_space =~ /^\s/) {
2908                                 WARN("SPACING",
2909                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
2910                         }
2911
2912                         if (show_type("SPACING") && $fix) {
2913                                 $fixed[$linenr - 1] =~
2914                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
2915                         }
2916                 }
2917
2918 # check for spacing round square brackets; allowed:
2919 #  1. with a type on the left -- int [] a;
2920 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2921 #  3. inside a curly brace -- = { [0...10] = 5 }
2922                 while ($line =~ /(.*?\s)\[/g) {
2923                         my ($where, $prefix) = ($-[1], $1);
2924                         if ($prefix !~ /$Type\s+$/ &&
2925                             ($where != 0 || $prefix !~ /^.\s+$/) &&
2926                             $prefix !~ /[{,]\s+$/) {
2927                                 if (ERROR("BRACKET_SPACE",
2928                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
2929                                     $fix) {
2930                                     $fixed[$linenr - 1] =~
2931                                         s/^(\+.*?)\s+\[/$1\[/;
2932                                 }
2933                         }
2934                 }
2935
2936 # check for spaces between functions and their parentheses.
2937                 while ($line =~ /($Ident)\s+\(/g) {
2938                         my $name = $1;
2939                         my $ctx_before = substr($line, 0, $-[1]);
2940                         my $ctx = "$ctx_before$name";
2941
2942                         # Ignore those directives where spaces _are_ permitted.
2943                         if ($name =~ /^(?:
2944                                 if|for|while|switch|return|case|
2945                                 volatile|__volatile__|
2946                                 __attribute__|format|__extension__|
2947                                 asm|__asm__)$/x)
2948                         {
2949                         # cpp #define statements have non-optional spaces, ie
2950                         # if there is a space between the name and the open
2951                         # parenthesis it is simply not a parameter group.
2952                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2953
2954                         # cpp #elif statement condition may start with a (
2955                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2956
2957                         # If this whole things ends with a type its most
2958                         # likely a typedef for a function.
2959                         } elsif ($ctx =~ /$Type$/) {
2960
2961                         } else {
2962                                 if (WARN("SPACING",
2963                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
2964                                              $fix) {
2965                                         $fixed[$linenr - 1] =~
2966                                             s/\b$name\s+\(/$name\(/;
2967                                 }
2968                         }
2969                 }
2970
2971 # Check operator spacing.
2972                 if (!($line=~/\#\s*include/)) {
2973                         my $fixed_line = "";
2974                         my $line_fixed = 0;
2975
2976                         my $ops = qr{
2977                                 <<=|>>=|<=|>=|==|!=|
2978                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
2979                                 =>|->|<<|>>|<|>|=|!|~|
2980                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
2981                                 \?:|\?|:
2982                         }x;
2983                         my @elements = split(/($ops|;)/, $opline);
2984
2985 ##                      print("element count: <" . $#elements . ">\n");
2986 ##                      foreach my $el (@elements) {
2987 ##                              print("el: <$el>\n");
2988 ##                      }
2989
2990                         my @fix_elements = ();
2991                         my $off = 0;
2992
2993                         foreach my $el (@elements) {
2994                                 push(@fix_elements, substr($rawline, $off, length($el)));
2995                                 $off += length($el);
2996                         }
2997
2998                         $off = 0;
2999
3000                         my $blank = copy_spacing($opline);
3001                         my $last_after = -1;
3002
3003                         for (my $n = 0; $n < $#elements; $n += 2) {
3004
3005                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3006
3007 ##                              print("n: <$n> good: <$good>\n");
3008
3009                                 $off += length($elements[$n]);
3010
3011                                 # Pick up the preceding and succeeding characters.
3012                                 my $ca = substr($opline, 0, $off);
3013                                 my $cc = '';
3014                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3015                                         $cc = substr($opline, $off + length($elements[$n + 1]));
3016                                 }
3017                                 my $cb = "$ca$;$cc";
3018
3019                                 my $a = '';
3020                                 $a = 'V' if ($elements[$n] ne '');
3021                                 $a = 'W' if ($elements[$n] =~ /\s$/);
3022                                 $a = 'C' if ($elements[$n] =~ /$;$/);
3023                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3024                                 $a = 'O' if ($elements[$n] eq '');
3025                                 $a = 'E' if ($ca =~ /^\s*$/);
3026
3027                                 my $op = $elements[$n + 1];
3028
3029                                 my $c = '';
3030                                 if (defined $elements[$n + 2]) {
3031                                         $c = 'V' if ($elements[$n + 2] ne '');
3032                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3033                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3034                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3035                                         $c = 'O' if ($elements[$n + 2] eq '');
3036                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3037                                 } else {
3038                                         $c = 'E';
3039                                 }
3040
3041                                 my $ctx = "${a}x${c}";
3042
3043                                 my $at = "(ctx:$ctx)";
3044
3045                                 my $ptr = substr($blank, 0, $off) . "^";
3046                                 my $hereptr = "$hereline$ptr\n";
3047
3048                                 # Pull out the value of this operator.
3049                                 my $op_type = substr($curr_values, $off + 1, 1);
3050
3051                                 # Get the full operator variant.
3052                                 my $opv = $op . substr($curr_vars, $off, 1);
3053
3054                                 # Ignore operators passed as parameters.
3055                                 if ($op_type ne 'V' &&
3056                                     $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3057
3058 #                               # Ignore comments
3059 #                               } elsif ($op =~ /^$;+$/) {
3060
3061                                 # ; should have either the end of line or a space or \ after it
3062                                 } elsif ($op eq ';') {
3063                                         if ($ctx !~ /.x[WEBC]/ &&
3064                                             $cc !~ /^\\/ && $cc !~ /^;/) {
3065                                                 if (ERROR("SPACING",
3066                                                           "space required after that '$op' $at\n" . $hereptr)) {
3067                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3068                                                         $line_fixed = 1;
3069                                                 }
3070                                         }
3071
3072                                 # // is a comment
3073                                 } elsif ($op eq '//') {
3074
3075                                 # No spaces for:
3076                                 #   ->
3077                                 #   :   when part of a bitfield
3078                                 } elsif ($op eq '->' || $opv eq ':B') {
3079                                         if ($ctx =~ /Wx.|.xW/) {
3080                                                 if (ERROR("SPACING",
3081                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3082                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3083                                                         if (defined $fix_elements[$n + 2]) {
3084                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3085                                                         }
3086                                                         $line_fixed = 1;
3087                                                 }
3088                                         }
3089
3090                                 # , must have a space on the right.
3091                                 } elsif ($op eq ',') {
3092                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3093                                                 if (ERROR("SPACING",
3094                                                           "space required after that '$op' $at\n" . $hereptr)) {
3095                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3096                                                         $line_fixed = 1;
3097                                                         $last_after = $n;
3098                                                 }
3099                                         }
3100
3101                                 # '*' as part of a type definition -- reported already.
3102                                 } elsif ($opv eq '*_') {
3103                                         #warn "'*' is part of type\n";
3104
3105                                 # unary operators should have a space before and
3106                                 # none after.  May be left adjacent to another
3107                                 # unary operator, or a cast
3108                                 } elsif ($op eq '!' || $op eq '~' ||
3109                                          $opv eq '*U' || $opv eq '-U' ||
3110                                          $opv eq '&U' || $opv eq '&&U') {
3111                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3112                                                 if (ERROR("SPACING",
3113                                                           "space required before that '$op' $at\n" . $hereptr)) {
3114                                                         if ($n != $last_after + 2) {
3115                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3116                                                                 $line_fixed = 1;
3117                                                         }
3118                                                 }
3119                                         }
3120                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3121                                                 # A unary '*' may be const
3122
3123                                         } elsif ($ctx =~ /.xW/) {
3124                                                 if (ERROR("SPACING",
3125                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3126                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3127                                                         if (defined $fix_elements[$n + 2]) {
3128                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3129                                                         }
3130                                                         $line_fixed = 1;
3131                                                 }
3132                                         }
3133
3134                                 # unary ++ and unary -- are allowed no space on one side.
3135                                 } elsif ($op eq '++' or $op eq '--') {
3136                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3137                                                 if (ERROR("SPACING",
3138                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
3139                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3140                                                         $line_fixed = 1;
3141                                                 }
3142                                         }
3143                                         if ($ctx =~ /Wx[BE]/ ||
3144                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3145                                                 if (ERROR("SPACING",
3146                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3147                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3148                                                         $line_fixed = 1;
3149                                                 }
3150                                         }
3151                                         if ($ctx =~ /ExW/) {
3152                                                 if (ERROR("SPACING",
3153                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3154                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3155                                                         if (defined $fix_elements[$n + 2]) {
3156                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3157                                                         }
3158                                                         $line_fixed = 1;
3159                                                 }
3160                                         }
3161
3162                                 # << and >> may either have or not have spaces both sides
3163                                 } elsif ($op eq '<<' or $op eq '>>' or
3164                                          $op eq '&' or $op eq '^' or $op eq '|' or
3165                                          $op eq '+' or $op eq '-' or
3166                                          $op eq '*' or $op eq '/' or
3167                                          $op eq '%')
3168                                 {
3169                                         if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3170                                                 if (ERROR("SPACING",
3171                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
3172                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3173                                                         if (defined $fix_elements[$n + 2]) {
3174                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3175                                                         }
3176                                                         $line_fixed = 1;
3177                                                 }
3178                                         }
3179
3180                                 # A colon needs no spaces before when it is
3181                                 # terminating a case value or a label.
3182                                 } elsif ($opv eq ':C' || $opv eq ':L') {
3183                                         if ($ctx =~ /Wx./) {
3184                                                 if (ERROR("SPACING",
3185                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3186                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3187                                                         $line_fixed = 1;
3188                                                 }
3189                                         }
3190
3191                                 # All the others need spaces both sides.
3192                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3193                                         my $ok = 0;
3194
3195                                         # Ignore email addresses <foo@bar>
3196                                         if (($op eq '<' &&
3197                                              $cc =~ /^\S+\@\S+>/) ||
3198                                             ($op eq '>' &&
3199                                              $ca =~ /<\S+\@\S+$/))
3200                                         {
3201                                                 $ok = 1;
3202                                         }
3203
3204                                         # messages are ERROR, but ?: are CHK
3205                                         if ($ok == 0) {
3206                                                 my $msg_type = \&ERROR;
3207                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3208
3209                                                 if (&{$msg_type}("SPACING",
3210                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {
3211                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3212                                                         if (defined $fix_elements[$n + 2]) {
3213                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3214                                                         }
3215                                                         $line_fixed = 1;
3216                                                 }
3217                                         }
3218                                 }
3219                                 $off += length($elements[$n + 1]);
3220
3221 ##                              print("n: <$n> GOOD: <$good>\n");
3222
3223                                 $fixed_line = $fixed_line . $good;
3224                         }
3225
3226                         if (($#elements % 2) == 0) {
3227                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
3228                         }
3229
3230                         if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3231                                 $fixed[$linenr - 1] = $fixed_line;
3232                         }
3233
3234
3235                 }
3236
3237 # check for whitespace before a non-naked semicolon
3238                 if ($line =~ /^\+.*\S\s+;\s*$/) {
3239                         if (WARN("SPACING",
3240                                  "space prohibited before semicolon\n" . $herecurr) &&
3241                             $fix) {
3242                                 1 while $fixed[$linenr - 1] =~
3243                                     s/^(\+.*\S)\s+;/$1;/;
3244                         }
3245                 }
3246
3247 # check for multiple assignments
3248                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3249                         CHK("MULTIPLE_ASSIGNMENTS",
3250                             "multiple assignments should be avoided\n" . $herecurr);
3251                 }
3252
3253 ## # check for multiple declarations, allowing for a function declaration
3254 ## # continuation.
3255 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3256 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3257 ##
3258 ##                      # Remove any bracketed sections to ensure we do not
3259 ##                      # falsly report the parameters of functions.
3260 ##                      my $ln = $line;
3261 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
3262 ##                      }
3263 ##                      if ($ln =~ /,/) {
3264 ##                              WARN("MULTIPLE_DECLARATION",
3265 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
3266 ##                      }
3267 ##              }
3268
3269 #need space before brace following if, while, etc
3270                 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3271                     $line =~ /do{/) {
3272                         if (ERROR("SPACING",
3273                                   "space required before the open brace '{'\n" . $herecurr) &&
3274                             $fix) {
3275                                 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3276                         }
3277                 }
3278
3279 ## # check for blank lines before declarations
3280 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3281 ##                  $prevrawline =~ /^.\s*$/) {
3282 ##                      WARN("SPACING",
3283 ##                           "No blank lines before declarations\n" . $hereprev);
3284 ##              }
3285 ##
3286
3287 # closing brace should have a space following it when it has anything
3288 # on the line
3289                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3290                         if (ERROR("SPACING",
3291                                   "space required after that close brace '}'\n" . $herecurr) &&
3292                             $fix) {
3293                                 $fixed[$linenr - 1] =~
3294                                     s/}((?!(?:,|;|\)))\S)/} $1/;
3295                         }
3296                 }
3297
3298 # check spacing on square brackets
3299                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3300                         if (ERROR("SPACING",
3301                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
3302                             $fix) {
3303                                 $fixed[$linenr - 1] =~
3304                                     s/\[\s+/\[/;
3305                         }
3306                 }
3307                 if ($line =~ /\s\]/) {
3308                         if (ERROR("SPACING",
3309                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3310                             $fix) {
3311                                 $fixed[$linenr - 1] =~
3312                                     s/\s+\]/\]/;
3313                         }
3314                 }
3315
3316 # check spacing on parentheses
3317                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3318                     $line !~ /for\s*\(\s+;/) {
3319                         if (ERROR("SPACING",
3320                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3321                             $fix) {
3322                                 $fixed[$linenr - 1] =~
3323                                     s/\(\s+/\(/;
3324                         }
3325                 }
3326                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3327                     $line !~ /for\s*\(.*;\s+\)/ &&
3328                     $line !~ /:\s+\)/) {
3329                         if (ERROR("SPACING",
3330                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3331                             $fix) {
3332                                 $fixed[$linenr - 1] =~
3333                                     s/\s+\)/\)/;
3334                         }
3335                 }
3336
3337 #goto labels aren't indented, allow a single space however
3338                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3339                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3340                         if (WARN("INDENTED_LABEL",
3341                                  "labels should not be indented\n" . $herecurr) &&
3342                             $fix) {
3343                                 $fixed[$linenr - 1] =~
3344                                     s/^(.)\s+/$1/;
3345                         }
3346                 }
3347
3348 # Return is not a function.
3349                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3350                         my $spacing = $1;
3351                         if ($^V && $^V ge 5.10.0 &&
3352                             $stat =~ /^.\s*return\s*$balanced_parens\s*;\s*$/) {
3353                                 ERROR("RETURN_PARENTHESES",
3354                                       "return is not a function, parentheses are not required\n" . $herecurr);
3355
3356                         } elsif ($spacing !~ /\s+/) {
3357                                 ERROR("SPACING",
3358                                       "space required before the open parenthesis '('\n" . $herecurr);
3359                         }
3360                 }
3361
3362 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3363                 if ($^V && $^V ge 5.10.0 &&
3364                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
3365                         my $openparens = $1;
3366                         my $count = $openparens =~ tr@\(@\(@;
3367                         my $msg = "";
3368                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3369                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
3370                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
3371                                 WARN("UNNECESSARY_PARENTHESES",
3372                                      "Unnecessary parentheses$msg\n" . $herecurr);
3373                         }
3374                 }
3375
3376 # Return of what appears to be an errno should normally be -'ve
3377                 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3378                         my $name = $1;
3379                         if ($name ne 'EOF' && $name ne 'ERROR') {
3380                                 WARN("USE_NEGATIVE_ERRNO",
3381                                      "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3382                         }
3383                 }
3384
3385 # Need a space before open parenthesis after if, while etc
3386                 if ($line =~ /\b(if|while|for|switch)\(/) {
3387                         if (ERROR("SPACING",
3388                                   "space required before the open parenthesis '('\n" . $herecurr) &&
3389                             $fix) {
3390                                 $fixed[$linenr - 1] =~
3391                                     s/\b(if|while|for|switch)\(/$1 \(/;
3392                         }
3393                 }
3394
3395 # Check for illegal assignment in if conditional -- and check for trailing
3396 # statements after the conditional.
3397                 if ($line =~ /do\s*(?!{)/) {
3398                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3399                                 ctx_statement_block($linenr, $realcnt, 0)
3400                                         if (!defined $stat);
3401                         my ($stat_next) = ctx_statement_block($line_nr_next,
3402                                                 $remain_next, $off_next);
3403                         $stat_next =~ s/\n./\n /g;
3404                         ##print "stat<$stat> stat_next<$stat_next>\n";
3405
3406                         if ($stat_next =~ /^\s*while\b/) {
3407                                 # If the statement carries leading newlines,
3408                                 # then count those as offsets.
3409                                 my ($whitespace) =
3410                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3411                                 my $offset =
3412                                         statement_rawlines($whitespace) - 1;
3413
3414                                 $suppress_whiletrailers{$line_nr_next +
3415                                                                 $offset} = 1;
3416                         }
3417                 }
3418                 if (!defined $suppress_whiletrailers{$linenr} &&
3419                     defined($stat) && defined($cond) &&
3420                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3421                         my ($s, $c) = ($stat, $cond);
3422
3423                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3424                                 ERROR("ASSIGN_IN_IF",
3425                                       "do not use assignment in if condition\n" . $herecurr);
3426                         }
3427
3428                         # Find out what is on the end of the line after the
3429                         # conditional.
3430                         substr($s, 0, length($c), '');
3431                         $s =~ s/\n.*//g;
3432                         $s =~ s/$;//g;  # Remove any comments
3433                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3434                             $c !~ /}\s*while\s*/)
3435                         {
3436                                 # Find out how long the conditional actually is.
3437                                 my @newlines = ($c =~ /\n/gs);
3438                                 my $cond_lines = 1 + $#newlines;
3439                                 my $stat_real = '';
3440
3441                                 $stat_real = raw_line($linenr, $cond_lines)
3442                                                         . "\n" if ($cond_lines);
3443                                 if (defined($stat_real) && $cond_lines > 1) {
3444                                         $stat_real = "[...]\n$stat_real";
3445                                 }
3446
3447                                 ERROR("TRAILING_STATEMENTS",
3448                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
3449                         }
3450                 }
3451
3452 # Check for bitwise tests written as boolean
3453                 if ($line =~ /
3454                         (?:
3455                                 (?:\[|\(|\&\&|\|\|)
3456                                 \s*0[xX][0-9]+\s*
3457                                 (?:\&\&|\|\|)
3458                         |
3459                                 (?:\&\&|\|\|)
3460                                 \s*0[xX][0-9]+\s*
3461                                 (?:\&\&|\|\||\)|\])
3462                         )/x)
3463                 {
3464                         WARN("HEXADECIMAL_BOOLEAN_TEST",
3465                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3466                 }
3467
3468 # if and else should not have general statements after it
3469                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3470                         my $s = $1;
3471                         $s =~ s/$;//g;  # Remove any comments
3472                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3473                                 ERROR("TRAILING_STATEMENTS",
3474                                       "trailing statements should be on next line\n" . $herecurr);
3475                         }
3476                 }
3477 # if should not continue a brace
3478                 if ($line =~ /}\s*if\b/) {
3479                         ERROR("TRAILING_STATEMENTS",
3480                               "trailing statements should be on next line\n" .
3481                                 $herecurr);
3482                 }
3483 # case and default should not have general statements after them
3484                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3485                     $line !~ /\G(?:
3486                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3487                         \s*return\s+
3488                     )/xg)
3489                 {
3490                         ERROR("TRAILING_STATEMENTS",
3491                               "trailing statements should be on next line\n" . $herecurr);
3492                 }
3493
3494                 # Check for }<nl>else {, these must be at the same
3495                 # indent level to be relevant to each other.
3496                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3497                                                 $previndent == $indent) {
3498                         ERROR("ELSE_AFTER_BRACE",
3499                               "else should follow close brace '}'\n" . $hereprev);
3500                 }
3501
3502                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3503                                                 $previndent == $indent) {
3504                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3505
3506                         # Find out what is on the end of the line after the
3507                         # conditional.
3508                         substr($s, 0, length($c), '');
3509                         $s =~ s/\n.*//g;
3510
3511                         if ($s =~ /^\s*;/) {
3512                                 ERROR("WHILE_AFTER_BRACE",
3513                                       "while should follow close brace '}'\n" . $hereprev);
3514                         }
3515                 }
3516
3517 #Specific variable tests
3518                 while ($line =~ m{($Constant|$Lval)}g) {
3519                         my $var = $1;
3520
3521 #gcc binary extension
3522                         if ($var =~ /^$Binary$/) {
3523                                 if (WARN("GCC_BINARY_CONSTANT",
3524                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3525                                     $fix) {
3526                                         my $hexval = sprintf("0x%x", oct($var));
3527                                         $fixed[$linenr - 1] =~
3528                                             s/\b$var\b/$hexval/;
3529                                 }
3530                         }
3531
3532 #CamelCase
3533                         if ($var !~ /^$Constant$/ &&
3534                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3535 #Ignore Page<foo> variants
3536                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3537 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3538                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3539                                 while ($var =~ m{($Ident)}g) {
3540                                         my $word = $1;
3541                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3542                                         if ($check) {
3543                                                 seed_camelcase_includes();
3544                                                 if (!$file && !$camelcase_file_seeded) {
3545                                                         seed_camelcase_file($realfile);
3546                                                         $camelcase_file_seeded = 1;
3547                                                 }
3548                                         }
3549                                         if (!defined $camelcase{$word}) {
3550                                                 $camelcase{$word} = 1;
3551                                                 CHK("CAMELCASE",
3552                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
3553                                         }
3554                                 }
3555                         }
3556                 }
3557
3558 #no spaces allowed after \ in define
3559                 if ($line =~ /\#\s*define.*\\\s+$/) {
3560                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3561                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3562                             $fix) {
3563                                 $fixed[$linenr - 1] =~ s/\s+$//;
3564                         }
3565                 }
3566
3567 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3568                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3569                         my $file = "$1.h";
3570                         my $checkfile = "include/linux/$file";
3571                         if (-f "$root/$checkfile" &&
3572                             $realfile ne $checkfile &&
3573                             $1 !~ /$allowed_asm_includes/)
3574                         {
3575                                 if ($realfile =~ m{^arch/}) {
3576                                         CHK("ARCH_INCLUDE_LINUX",
3577                                             "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3578                                 } else {
3579                                         WARN("INCLUDE_LINUX",
3580                                              "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3581                                 }
3582                         }
3583                 }
3584
3585 # multi-statement macros should be enclosed in a do while loop, grab the
3586 # first statement and ensure its the whole macro if its not enclosed
3587 # in a known good container
3588                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3589                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3590                         my $ln = $linenr;
3591                         my $cnt = $realcnt;
3592                         my ($off, $dstat, $dcond, $rest);
3593                         my $ctx = '';
3594                         ($dstat, $dcond, $ln, $cnt, $off) =
3595                                 ctx_statement_block($linenr, $realcnt, 0);
3596                         $ctx = $dstat;
3597                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3598                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3599
3600                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3601                         $dstat =~ s/$;//g;
3602                         $dstat =~ s/\\\n.//g;
3603                         $dstat =~ s/^\s*//s;
3604                         $dstat =~ s/\s*$//s;
3605
3606                         # Flatten any parentheses and braces
3607                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3608                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
3609                                $dstat =~ s/\[[^\[\]]*\]/1/)
3610                         {
3611                         }
3612
3613                         # Flatten any obvious string concatentation.
3614                         while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3615                                $dstat =~ s/$Ident\s*("X*")/$1/)
3616                         {
3617                         }
3618
3619                         my $exceptions = qr{
3620                                 $Declare|
3621                                 module_param_named|
3622                                 MODULE_PARM_DESC|
3623                                 DECLARE_PER_CPU|
3624                                 DEFINE_PER_CPU|
3625                                 __typeof__\(|
3626                                 union|
3627                                 struct|
3628                                 \.$Ident\s*=\s*|
3629                                 ^\"|\"$
3630                         }x;
3631                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3632                         if ($dstat ne '' &&
3633                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
3634                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
3635                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3636                             $dstat !~ /^'X'$/ &&                                        # character constants
3637                             $dstat !~ /$exceptions/ &&
3638                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
3639                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
3640                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
3641                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
3642                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
3643                             $dstat !~ /^do\s*{/ &&                                      # do {...
3644                             $dstat !~ /^\({/ &&                                         # ({...
3645                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3646                         {
3647                                 $ctx =~ s/\n*$//;
3648                                 my $herectx = $here . "\n";
3649                                 my $cnt = statement_rawlines($ctx);
3650
3651                                 for (my $n = 0; $n < $cnt; $n++) {
3652                                         $herectx .= raw_line($linenr, $n) . "\n";
3653                                 }
3654
3655                                 if ($dstat =~ /;/) {
3656                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3657                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3658                                 } else {
3659                                         ERROR("COMPLEX_MACRO",
3660                                               "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3661                                 }
3662                         }
3663
3664 # check for line continuations outside of #defines, preprocessor #, and asm
3665
3666                 } else {
3667                         if ($prevline !~ /^..*\\$/ &&
3668                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
3669                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
3670                             $line =~ /^\+.*\\$/) {
3671                                 WARN("LINE_CONTINUATIONS",
3672                                      "Avoid unnecessary line continuations\n" . $herecurr);
3673                         }
3674                 }
3675
3676 # do {} while (0) macro tests:
3677 # single-statement macros do not need to be enclosed in do while (0) loop,
3678 # macro should not end with a semicolon
3679                 if ($^V && $^V ge 5.10.0 &&
3680                     $realfile !~ m@/vmlinux.lds.h$@ &&
3681                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3682                         my $ln = $linenr;
3683                         my $cnt = $realcnt;
3684                         my ($off, $dstat, $dcond, $rest);
3685                         my $ctx = '';
3686                         ($dstat, $dcond, $ln, $cnt, $off) =
3687                                 ctx_statement_block($linenr, $realcnt, 0);
3688                         $ctx = $dstat;
3689
3690                         $dstat =~ s/\\\n.//g;
3691
3692                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3693                                 my $stmts = $2;
3694                                 my $semis = $3;
3695
3696                                 $ctx =~ s/\n*$//;
3697                                 my $cnt = statement_rawlines($ctx);
3698                                 my $herectx = $here . "\n";
3699
3700                                 for (my $n = 0; $n < $cnt; $n++) {
3701                                         $herectx .= raw_line($linenr, $n) . "\n";
3702                                 }
3703
3704                                 if (($stmts =~ tr/;/;/) == 1 &&
3705                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
3706                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3707                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3708                                 }
3709                                 if (defined $semis && $semis ne "") {
3710                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3711                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3712                                 }
3713                         }
3714                 }
3715
3716 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3717 # all assignments may have only one of the following with an assignment:
3718 #       .
3719 #       ALIGN(...)
3720 #       VMLINUX_SYMBOL(...)
3721                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3722                         WARN("MISSING_VMLINUX_SYMBOL",
3723                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3724                 }
3725
3726 # check for redundant bracing round if etc
3727                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3728                         my ($level, $endln, @chunks) =
3729                                 ctx_statement_full($linenr, $realcnt, 1);
3730                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3731                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3732                         if ($#chunks > 0 && $level == 0) {
3733                                 my @allowed = ();
3734                                 my $allow = 0;
3735                                 my $seen = 0;
3736                                 my $herectx = $here . "\n";
3737                                 my $ln = $linenr - 1;
3738                                 for my $chunk (@chunks) {
3739                                         my ($cond, $block) = @{$chunk};
3740
3741                                         # If the condition carries leading newlines, then count those as offsets.
3742                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3743                                         my $offset = statement_rawlines($whitespace) - 1;
3744
3745                                         $allowed[$allow] = 0;
3746                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3747
3748                                         # We have looked at and allowed this specific line.
3749                                         $suppress_ifbraces{$ln + $offset} = 1;
3750
3751                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3752                                         $ln += statement_rawlines($block) - 1;
3753
3754                                         substr($block, 0, length($cond), '');
3755
3756                                         $seen++ if ($block =~ /^\s*{/);
3757
3758                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3759                                         if (statement_lines($cond) > 1) {
3760                                                 #print "APW: ALLOWED: cond<$cond>\n";
3761                                                 $allowed[$allow] = 1;
3762                                         }
3763                                         if ($block =~/\b(?:if|for|while)\b/) {
3764                                                 #print "APW: ALLOWED: block<$block>\n";
3765                                                 $allowed[$allow] = 1;
3766                                         }
3767                                         if (statement_block_size($block) > 1) {
3768                                                 #print "APW: ALLOWED: lines block<$block>\n";
3769                                                 $allowed[$allow] = 1;
3770                                         }
3771                                         $allow++;
3772                                 }
3773                                 if ($seen) {
3774                                         my $sum_allowed = 0;
3775                                         foreach (@allowed) {
3776                                                 $sum_allowed += $_;
3777                                         }
3778                                         if ($sum_allowed == 0) {
3779                                                 WARN("BRACES",
3780                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
3781                                         } elsif ($sum_allowed != $allow &&
3782                                                  $seen != $allow) {
3783                                                 CHK("BRACES",
3784                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
3785                                         }
3786                                 }
3787                         }
3788                 }
3789                 if (!defined $suppress_ifbraces{$linenr - 1} &&
3790                                         $line =~ /\b(if|while|for|else)\b/) {
3791                         my $allowed = 0;
3792
3793                         # Check the pre-context.
3794                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3795                                 #print "APW: ALLOWED: pre<$1>\n";
3796                                 $allowed = 1;
3797                         }
3798
3799                         my ($level, $endln, @chunks) =
3800                                 ctx_statement_full($linenr, $realcnt, $-[0]);
3801
3802                         # Check the condition.
3803                         my ($cond, $block) = @{$chunks[0]};
3804                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3805                         if (defined $cond) {
3806                                 substr($block, 0, length($cond), '');
3807                         }
3808                         if (statement_lines($cond) > 1) {
3809                                 #print "APW: ALLOWED: cond<$cond>\n";
3810                                 $allowed = 1;
3811                         }
3812                         if ($block =~/\b(?:if|for|while)\b/) {
3813                                 #print "APW: ALLOWED: block<$block>\n";
3814                                 $allowed = 1;
3815                         }
3816                         if (statement_block_size($block) > 1) {
3817                                 #print "APW: ALLOWED: lines block<$block>\n";
3818                                 $allowed = 1;
3819                         }
3820                         # Check the post-context.
3821                         if (defined $chunks[1]) {
3822                                 my ($cond, $block) = @{$chunks[1]};
3823                                 if (defined $cond) {
3824                                         substr($block, 0, length($cond), '');
3825                                 }
3826                                 if ($block =~ /^\s*\{/) {
3827                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
3828                                         $allowed = 1;
3829                                 }
3830                         }
3831                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3832                                 my $herectx = $here . "\n";
3833                                 my $cnt = statement_rawlines($block);
3834
3835                                 for (my $n = 0; $n < $cnt; $n++) {
3836                                         $herectx .= raw_line($linenr, $n) . "\n";
3837                                 }
3838
3839                                 WARN("BRACES",
3840                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
3841                         }
3842                 }
3843
3844 # check for unnecessary blank lines around braces
3845                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
3846                         CHK("BRACES",
3847                             "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3848                 }
3849                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
3850                         CHK("BRACES",
3851                             "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3852                 }
3853
3854 # no volatiles please
3855                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3856                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3857                         WARN("VOLATILE",
3858                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3859                 }
3860
3861 # warn about #if 0
3862                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3863                         CHK("REDUNDANT_CODE",
3864                             "if this code is redundant consider removing it\n" .
3865                                 $herecurr);
3866                 }
3867
3868 # check for needless "if (<foo>) fn(<foo>)" uses
3869                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
3870                         my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
3871                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
3872                                 WARN('NEEDLESS_IF',
3873                                      "$1(NULL) is safe this check is probably not required\n" . $hereprev);
3874                         }
3875                 }
3876
3877 # check for bad placement of section $InitAttribute (e.g.: __initdata)
3878                 if ($line =~ /(\b$InitAttribute\b)/) {
3879                         my $attr = $1;
3880                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
3881                                 my $ptr = $1;
3882                                 my $var = $2;
3883                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
3884                                       ERROR("MISPLACED_INIT",
3885                                             "$attr should be placed after $var\n" . $herecurr)) ||
3886                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
3887                                       WARN("MISPLACED_INIT",
3888                                            "$attr should be placed after $var\n" . $herecurr))) &&
3889                                     $fix) {
3890                                         $fixed[$linenr - 1] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
3891                                 }
3892                         }
3893                 }
3894
3895 # check for $InitAttributeData (ie: __initdata) with const
3896                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
3897                         my $attr = $1;
3898                         $attr =~ /($InitAttributePrefix)(.*)/;
3899                         my $attr_prefix = $1;
3900                         my $attr_type = $2;
3901                         if (ERROR("INIT_ATTRIBUTE",
3902                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
3903                             $fix) {
3904                                 $fixed[$linenr - 1] =~
3905                                     s/$InitAttributeData/${attr_prefix}initconst/;
3906                         }
3907                 }
3908
3909 # check for $InitAttributeConst (ie: __initconst) without const
3910                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
3911                         my $attr = $1;
3912                         if (ERROR("INIT_ATTRIBUTE",
3913                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
3914                             $fix) {
3915                                 my $lead = $fixed[$linenr - 1] =~
3916                                     /(^\+\s*(?:static\s+))/;
3917                                 $lead = rtrim($1);
3918                                 $lead = "$lead " if ($lead !~ /^\+$/);
3919                                 $lead = "${lead}const ";
3920                                 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
3921                         }
3922                 }
3923
3924 # prefer usleep_range over udelay
3925                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
3926                         my $delay = $1;
3927                         # ignore udelay's < 10, however
3928                         if (! ($delay < 10) ) {
3929                                 CHK("USLEEP_RANGE",
3930                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
3931                         }
3932                         if ($delay > 2000) {
3933                                 WARN("LONG_UDELAY",
3934                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
3935                         }
3936                 }
3937
3938 # warn about unexpectedly long msleep's
3939                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3940                         if ($1 < 20) {
3941                                 WARN("MSLEEP",
3942                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
3943                         }
3944                 }
3945
3946 # check for comparisons of jiffies
3947                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
3948                         WARN("JIFFIES_COMPARISON",
3949                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
3950                 }
3951
3952 # check for comparisons of get_jiffies_64()
3953                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
3954                         WARN("JIFFIES_COMPARISON",
3955                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
3956                 }
3957
3958 # warn about #ifdefs in C files
3959 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3960 #                       print "#ifdef in C files should be avoided\n";
3961 #                       print "$herecurr";
3962 #                       $clean = 0;
3963 #               }
3964
3965 # warn about spacing in #ifdefs
3966                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
3967                         if (ERROR("SPACING",
3968                                   "exactly one space required after that #$1\n" . $herecurr) &&
3969                             $fix) {
3970                                 $fixed[$linenr - 1] =~
3971                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
3972                         }
3973
3974                 }
3975
3976 # check for spinlock_t definitions without a comment.
3977                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
3978                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
3979                         my $which = $1;
3980                         if (!ctx_has_comment($first_line, $linenr)) {
3981                                 CHK("UNCOMMENTED_DEFINITION",
3982                                     "$1 definition without comment\n" . $herecurr);
3983                         }
3984                 }
3985 # check for memory barriers without a comment.
3986                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3987                         if (!ctx_has_comment($first_line, $linenr)) {
3988                                 WARN("MEMORY_BARRIER",
3989                                      "memory barrier without comment\n" . $herecurr);
3990                         }
3991                 }
3992 # check of hardware specific defines
3993                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3994                         CHK("ARCH_DEFINES",
3995                             "architecture specific defines should be avoided\n" .  $herecurr);
3996                 }
3997
3998 # Check that the storage class is at the beginning of a declaration
3999                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4000                         WARN("STORAGE_CLASS",
4001                              "storage class should be at the beginning of the declaration\n" . $herecurr)
4002                 }
4003
4004 # check the location of the inline attribute, that it is between
4005 # storage class and type.
4006                 if ($line =~ /\b$Type\s+$Inline\b/ ||
4007                     $line =~ /\b$Inline\s+$Storage\b/) {
4008                         ERROR("INLINE_LOCATION",
4009                               "inline keyword should sit between storage class and type\n" . $herecurr);
4010                 }
4011
4012 # Check for __inline__ and __inline, prefer inline
4013                 if ($realfile !~ m@\binclude/uapi/@ &&
4014                     $line =~ /\b(__inline__|__inline)\b/) {
4015                         if (WARN("INLINE",
4016                                  "plain inline is preferred over $1\n" . $herecurr) &&
4017                             $fix) {
4018                                 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4019
4020                         }
4021                 }
4022
4023 # Check for __attribute__ packed, prefer __packed
4024                 if ($realfile !~ m@\binclude/uapi/@ &&
4025                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4026                         WARN("PREFER_PACKED",
4027                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4028                 }
4029
4030 # Check for __attribute__ aligned, prefer __aligned
4031                 if ($realfile !~ m@\binclude/uapi/@ &&
4032                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4033                         WARN("PREFER_ALIGNED",
4034                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4035                 }
4036
4037 # Check for __attribute__ format(printf, prefer __printf
4038                 if ($realfile !~ m@\binclude/uapi/@ &&
4039                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4040                         if (WARN("PREFER_PRINTF",
4041                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4042                             $fix) {
4043                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4044
4045                         }
4046                 }
4047
4048 # Check for __attribute__ format(scanf, prefer __scanf
4049                 if ($realfile !~ m@\binclude/uapi/@ &&
4050                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4051                         if (WARN("PREFER_SCANF",
4052                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4053                             $fix) {
4054                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4055                         }
4056                 }
4057
4058 # check for sizeof(&)
4059                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4060                         WARN("SIZEOF_ADDRESS",
4061                              "sizeof(& should be avoided\n" . $herecurr);
4062                 }
4063
4064 # check for sizeof without parenthesis
4065                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4066                         if (WARN("SIZEOF_PARENTHESIS",
4067                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4068                             $fix) {
4069                                 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4070                         }
4071                 }
4072
4073 # check for line continuations in quoted strings with odd counts of "
4074                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4075                         WARN("LINE_CONTINUATIONS",
4076                              "Avoid line continuations in quoted strings\n" . $herecurr);
4077                 }
4078
4079 # check for struct spinlock declarations
4080                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4081                         WARN("USE_SPINLOCK_T",
4082                              "struct spinlock should be spinlock_t\n" . $herecurr);
4083                 }
4084
4085 # check for seq_printf uses that could be seq_puts
4086                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4087                         my $fmt = get_quoted_string($line, $rawline);
4088                         if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4089                                 if (WARN("PREFER_SEQ_PUTS",
4090                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4091                                     $fix) {
4092                                         $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4093                                 }
4094                         }
4095                 }
4096
4097 # Check for misused memsets
4098                 if ($^V && $^V ge 5.10.0 &&
4099                     defined $stat &&
4100                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4101
4102                         my $ms_addr = $2;
4103                         my $ms_val = $7;
4104                         my $ms_size = $12;
4105
4106                         if ($ms_size =~ /^(0x|)0$/i) {
4107                                 ERROR("MEMSET",
4108                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4109                         } elsif ($ms_size =~ /^(0x|)1$/i) {
4110                                 WARN("MEMSET",
4111                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4112                         }
4113                 }
4114
4115 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4116                 if ($^V && $^V ge 5.10.0 &&
4117                     $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4118                         if (WARN("PREFER_ETHER_ADDR_COPY",
4119                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4120                             $fix) {
4121                                 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4122                         }
4123                 }
4124
4125 # typecasts on min/max could be min_t/max_t
4126                 if ($^V && $^V ge 5.10.0 &&
4127                     defined $stat &&
4128                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4129                         if (defined $2 || defined $7) {
4130                                 my $call = $1;
4131                                 my $cast1 = deparenthesize($2);
4132                                 my $arg1 = $3;
4133                                 my $cast2 = deparenthesize($7);
4134                                 my $arg2 = $8;
4135                                 my $cast;
4136
4137                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4138                                         $cast = "$cast1 or $cast2";
4139                                 } elsif ($cast1 ne "") {
4140                                         $cast = $cast1;
4141                                 } else {
4142                                         $cast = $cast2;
4143                                 }
4144                                 WARN("MINMAX",
4145                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4146                         }
4147                 }
4148
4149 # check usleep_range arguments
4150                 if ($^V && $^V ge 5.10.0 &&
4151                     defined $stat &&
4152                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4153                         my $min = $1;
4154                         my $max = $7;
4155                         if ($min eq $max) {
4156                                 WARN("USLEEP_RANGE",
4157                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4158                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4159                                  $min > $max) {
4160                                 WARN("USLEEP_RANGE",
4161                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4162                         }
4163                 }
4164
4165 # check for naked sscanf
4166                 if ($^V && $^V ge 5.10.0 &&
4167                     defined $stat &&
4168                     $stat =~ /\bsscanf\b/ &&
4169                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4170                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4171                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4172                         my $lc = $stat =~ tr@\n@@;
4173                         $lc = $lc + $linenr;
4174                         my $stat_real = raw_line($linenr, 0);
4175                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
4176                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4177                         }
4178                         WARN("NAKED_SSCANF",
4179                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4180                 }
4181
4182 # check for new externs in .h files.
4183                 if ($realfile =~ /\.h$/ &&
4184                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4185                         if (CHK("AVOID_EXTERNS",
4186                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4187                             $fix) {
4188                                 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4189                         }
4190                 }
4191
4192 # check for new externs in .c files.
4193                 if ($realfile =~ /\.c$/ && defined $stat &&
4194                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4195                 {
4196                         my $function_name = $1;
4197                         my $paren_space = $2;
4198
4199                         my $s = $stat;
4200                         if (defined $cond) {
4201                                 substr($s, 0, length($cond), '');
4202                         }
4203                         if ($s =~ /^\s*;/ &&
4204                             $function_name ne 'uninitialized_var')
4205                         {
4206                                 WARN("AVOID_EXTERNS",
4207                                      "externs should be avoided in .c files\n" .  $herecurr);
4208                         }
4209
4210                         if ($paren_space =~ /\n/) {
4211                                 WARN("FUNCTION_ARGUMENTS",
4212                                      "arguments for function declarations should follow identifier\n" . $herecurr);
4213                         }
4214
4215                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4216                     $stat =~ /^.\s*extern\s+/)
4217                 {
4218                         WARN("AVOID_EXTERNS",
4219                              "externs should be avoided in .c files\n" .  $herecurr);
4220                 }
4221
4222 # checks for new __setup's
4223                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4224                         my $name = $1;
4225
4226                         if (!grep(/$name/, @setup_docs)) {
4227                                 CHK("UNDOCUMENTED_SETUP",
4228                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4229                         }
4230                 }
4231
4232 # check for pointless casting of kmalloc return
4233                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4234                         WARN("UNNECESSARY_CASTS",
4235                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4236                 }
4237
4238 # alloc style
4239 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4240                 if ($^V && $^V ge 5.10.0 &&
4241                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4242                         CHK("ALLOC_SIZEOF_STRUCT",
4243                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4244                 }
4245
4246 # check for krealloc arg reuse
4247                 if ($^V && $^V ge 5.10.0 &&
4248                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4249                         WARN("KREALLOC_ARG_REUSE",
4250                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4251                 }
4252
4253 # check for alloc argument mismatch
4254                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4255                         WARN("ALLOC_ARRAY_ARGS",
4256                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4257                 }
4258
4259 # check for GFP_NOWAIT use
4260                 if ($line =~ /\b__GFP_NOFAIL\b/) {
4261                         WARN("__GFP_NOFAIL",
4262                              "Use of __GFP_NOFAIL is deprecated, no new users should be added\n" . $herecurr);
4263                 }
4264
4265 # check for multiple semicolons
4266                 if ($line =~ /;\s*;\s*$/) {
4267                         if (WARN("ONE_SEMICOLON",
4268                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
4269                             $fix) {
4270                                 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4271                         }
4272                 }
4273
4274 # check for case / default statements not preceeded by break/fallthrough/switch
4275                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4276                         my $has_break = 0;
4277                         my $has_statement = 0;
4278                         my $count = 0;
4279                         my $prevline = $linenr;
4280                         while ($prevline > 1 && $count < 3 && !$has_break) {
4281                                 $prevline--;
4282                                 my $rline = $rawlines[$prevline - 1];
4283                                 my $fline = $lines[$prevline - 1];
4284                                 last if ($fline =~ /^\@\@/);
4285                                 next if ($fline =~ /^\-/);
4286                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4287                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4288                                 next if ($fline =~ /^.[\s$;]*$/);
4289                                 $has_statement = 1;
4290                                 $count++;
4291                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4292                         }
4293                         if (!$has_break && $has_statement) {
4294                                 WARN("MISSING_BREAK",
4295                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4296                         }
4297                 }
4298
4299 # check for switch/default statements without a break;
4300                 if ($^V && $^V ge 5.10.0 &&
4301                     defined $stat &&
4302                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4303                         my $ctx = '';
4304                         my $herectx = $here . "\n";
4305                         my $cnt = statement_rawlines($stat);
4306                         for (my $n = 0; $n < $cnt; $n++) {
4307                                 $herectx .= raw_line($linenr, $n) . "\n";
4308                         }
4309                         WARN("DEFAULT_NO_BREAK",
4310                              "switch default: should use break\n" . $herectx);
4311                 }
4312
4313 # check for gcc specific __FUNCTION__
4314                 if ($line =~ /\b__FUNCTION__\b/) {
4315                         if (WARN("USE_FUNC",
4316                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
4317                             $fix) {
4318                                 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4319                         }
4320                 }
4321
4322 # check for use of yield()
4323                 if ($line =~ /\byield\s*\(\s*\)/) {
4324                         WARN("YIELD",
4325                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
4326                 }
4327
4328 # check for comparisons against true and false
4329                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4330                         my $lead = $1;
4331                         my $arg = $2;
4332                         my $test = $3;
4333                         my $otype = $4;
4334                         my $trail = $5;
4335                         my $op = "!";
4336
4337                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4338
4339                         my $type = lc($otype);
4340                         if ($type =~ /^(?:true|false)$/) {
4341                                 if (("$test" eq "==" && "$type" eq "true") ||
4342                                     ("$test" eq "!=" && "$type" eq "false")) {
4343                                         $op = "";
4344                                 }
4345
4346                                 CHK("BOOL_COMPARISON",
4347                                     "Using comparison to $otype is error prone\n" . $herecurr);
4348
4349 ## maybe suggesting a correct construct would better
4350 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4351
4352                         }
4353                 }
4354
4355 # check for semaphores initialized locked
4356                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4357                         WARN("CONSIDER_COMPLETION",
4358                              "consider using a completion\n" . $herecurr);
4359                 }
4360
4361 # recommend kstrto* over simple_strto* and strict_strto*
4362                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4363                         WARN("CONSIDER_KSTRTO",
4364                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
4365                 }
4366
4367 # check for __initcall(), use device_initcall() explicitly please
4368                 if ($line =~ /^.\s*__initcall\s*\(/) {
4369                         WARN("USE_DEVICE_INITCALL",
4370                              "please use device_initcall() instead of __initcall()\n" . $herecurr);
4371                 }
4372
4373 # check for various ops structs, ensure they are const.
4374                 my $struct_ops = qr{acpi_dock_ops|
4375                                 address_space_operations|
4376                                 backlight_ops|
4377                                 block_device_operations|
4378                                 dentry_operations|
4379                                 dev_pm_ops|
4380                                 dma_map_ops|
4381                                 extent_io_ops|
4382                                 file_lock_operations|
4383                                 file_operations|
4384                                 hv_ops|
4385                                 ide_dma_ops|
4386                                 intel_dvo_dev_ops|
4387                                 item_operations|
4388                                 iwl_ops|
4389                                 kgdb_arch|
4390                                 kgdb_io|
4391                                 kset_uevent_ops|
4392                                 lock_manager_operations|
4393                                 microcode_ops|
4394                                 mtrr_ops|
4395                                 neigh_ops|
4396                                 nlmsvc_binding|
4397                                 pci_raw_ops|
4398                                 pipe_buf_operations|
4399                                 platform_hibernation_ops|
4400                                 platform_suspend_ops|
4401                                 proto_ops|
4402                                 rpc_pipe_ops|
4403                                 seq_operations|
4404                                 snd_ac97_build_ops|
4405                                 soc_pcmcia_socket_ops|
4406                                 stacktrace_ops|
4407                                 sysfs_ops|
4408                                 tty_operations|
4409                                 usb_mon_operations|
4410                                 wd_ops}x;
4411                 if ($line !~ /\bconst\b/ &&
4412                     $line =~ /\bstruct\s+($struct_ops)\b/) {
4413                         WARN("CONST_STRUCT",
4414                              "struct $1 should normally be const\n" .
4415                                 $herecurr);
4416                 }
4417
4418 # use of NR_CPUS is usually wrong
4419 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4420                 if ($line =~ /\bNR_CPUS\b/ &&
4421                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4422                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4423                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4424                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4425                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4426                 {
4427                         WARN("NR_CPUS",
4428                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4429                 }
4430
4431 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4432                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4433                         ERROR("DEFINE_ARCH_HAS",
4434                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4435                 }
4436
4437 # check for %L{u,d,i} in strings
4438                 my $string;
4439                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4440                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4441                         $string =~ s/%%/__/g;
4442                         if ($string =~ /(?<!%)%L[udi]/) {
4443                                 WARN("PRINTF_L",
4444                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4445                                 last;
4446                         }
4447                 }
4448
4449 # whine mightly about in_atomic
4450                 if ($line =~ /\bin_atomic\s*\(/) {
4451                         if ($realfile =~ m@^drivers/@) {
4452                                 ERROR("IN_ATOMIC",
4453                                       "do not use in_atomic in drivers\n" . $herecurr);
4454                         } elsif ($realfile !~ m@^kernel/@) {
4455                                 WARN("IN_ATOMIC",
4456                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4457                         }
4458                 }
4459
4460 # check for lockdep_set_novalidate_class
4461                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4462                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
4463                         if ($realfile !~ m@^kernel/lockdep@ &&
4464                             $realfile !~ m@^include/linux/lockdep@ &&
4465                             $realfile !~ m@^drivers/base/core@) {
4466                                 ERROR("LOCKDEP",
4467                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4468                         }
4469                 }
4470
4471                 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4472                     $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4473                         WARN("EXPORTED_WORLD_WRITABLE",
4474                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4475                 }
4476         }
4477
4478         # If we have no input at all, then there is nothing to report on
4479         # so just keep quiet.
4480         if ($#rawlines == -1) {
4481                 exit(0);
4482         }
4483
4484         # In mailback mode only produce a report in the negative, for
4485         # things that appear to be patches.
4486         if ($mailback && ($clean == 1 || !$is_patch)) {
4487                 exit(0);
4488         }
4489
4490         # This is not a patch, and we are are in 'no-patch' mode so
4491         # just keep quiet.
4492         if (!$chk_patch && !$is_patch) {
4493                 exit(0);
4494         }
4495
4496         if (!$is_patch) {
4497                 ERROR("NOT_UNIFIED_DIFF",
4498                       "Does not appear to be a unified-diff format patch\n");
4499         }
4500         if ($is_patch && $chk_signoff && $signoff == 0) {
4501                 ERROR("MISSING_SIGN_OFF",
4502                       "Missing Signed-off-by: line(s)\n");
4503         }
4504
4505         print report_dump();
4506         if ($summary && !($clean == 1 && $quiet == 1)) {
4507                 print "$filename " if ($summary_file);
4508                 print "total: $cnt_error errors, $cnt_warn warnings, " .
4509                         (($check)? "$cnt_chk checks, " : "") .
4510                         "$cnt_lines lines checked\n";
4511                 print "\n" if ($quiet == 0);
4512         }
4513
4514         if ($quiet == 0) {
4515
4516                 if ($^V lt 5.10.0) {
4517                         print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4518                         print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4519                 }
4520
4521                 # If there were whitespace errors which cleanpatch can fix
4522                 # then suggest that.
4523                 if ($rpt_cleaners) {
4524                         print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4525                         print "      scripts/cleanfile\n\n";
4526                         $rpt_cleaners = 0;
4527                 }
4528         }
4529
4530         hash_show_words(\%use_type, "Used");
4531         hash_show_words(\%ignore_type, "Ignored");
4532
4533         if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4534                 my $newfile = $filename;
4535                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4536                 my $linecount = 0;
4537                 my $f;
4538
4539                 open($f, '>', $newfile)
4540                     or die "$P: Can't open $newfile for write\n";
4541                 foreach my $fixed_line (@fixed) {
4542                         $linecount++;
4543                         if ($file) {
4544                                 if ($linecount > 3) {
4545                                         $fixed_line =~ s/^\+//;
4546                                         print $f $fixed_line. "\n";
4547                                 }
4548                         } else {
4549                                 print $f $fixed_line . "\n";
4550                         }
4551                 }
4552                 close($f);
4553
4554                 if (!$quiet) {
4555                         print << "EOM";
4556 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4557
4558 Do _NOT_ trust the results written to this file.
4559 Do _NOT_ submit these changes without inspecting them for correctness.
4560
4561 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4562 No warranties, expressed or implied...
4563
4564 EOM
4565                 }
4566         }
4567
4568         if ($clean == 1 && $quiet == 0) {
4569                 print "$vname has no obvious style problems and is ready for submission.\n"
4570         }
4571         if ($clean == 0 && $quiet == 0) {
4572                 print << "EOM";
4573 $vname has style problems, please review.
4574
4575 If any of these errors are false positives, please report
4576 them to the maintainer, see CHECKPATCH in MAINTAINERS.
4577 EOM
4578         }
4579
4580         return $clean;
4581 }