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