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 &&
2078                         (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2079                          ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2080
2081                         my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2082
2083                         my $dt_path = $root . "/Documentation/devicetree/bindings/";
2084                         my $vp_file = $dt_path . "vendor-prefixes.txt";
2085
2086                         foreach my $compat (@compats) {
2087                                 my $compat2 = $compat;
2088                                 $compat2 =~ s/\,[a-z]*\-/\,<\.\*>\-/;
2089                                 `grep -Erq "$compat|$compat2" $dt_path`;
2090                                 if ( $? >> 8 ) {
2091                                         WARN("UNDOCUMENTED_DT_STRING",
2092                                              "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2093                                 }
2094
2095                                 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2096                                 my $vendor = $1;
2097                                 `grep -Eq "^$vendor\\b" $vp_file`;
2098                                 if ( $? >> 8 ) {
2099                                         WARN("UNDOCUMENTED_DT_STRING",
2100                                              "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2101                                 }
2102                         }
2103                 }
2104
2105 # check we are in a valid source file if not then ignore this hunk
2106                 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2107
2108 #line length limit
2109                 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2110                     $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2111                     !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2112                     $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2113                     $length > $max_line_length)
2114                 {
2115                         WARN("LONG_LINE",
2116                              "line over $max_line_length characters\n" . $herecurr);
2117                 }
2118
2119 # Check for user-visible strings broken across lines, which breaks the ability
2120 # to grep for the string.  Make exceptions when the previous string ends in a
2121 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2122 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2123                 if ($line =~ /^\+\s*"/ &&
2124                     $prevline =~ /"\s*$/ &&
2125                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2126                         WARN("SPLIT_STRING",
2127                              "quoted string split across lines\n" . $hereprev);
2128                 }
2129
2130 # check for spaces before a quoted newline
2131                 if ($rawline =~ /^.*\".*\s\\n/) {
2132                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2133                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2134                             $fix) {
2135                                 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2136                         }
2137
2138                 }
2139
2140 # check for adding lines without a newline.
2141                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2142                         WARN("MISSING_EOF_NEWLINE",
2143                              "adding a line without newline at end of file\n" . $herecurr);
2144                 }
2145
2146 # Blackfin: use hi/lo macros
2147                 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2148                         if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2149                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2150                                 ERROR("LO_MACRO",
2151                                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2152                         }
2153                         if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2154                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2155                                 ERROR("HI_MACRO",
2156                                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2157                         }
2158                 }
2159
2160 # check we are in a valid source file C or perl if not then ignore this hunk
2161                 next if ($realfile !~ /\.(h|c|pl)$/);
2162
2163 # at the beginning of a line any tabs must come first and anything
2164 # more than 8 must use tabs.
2165                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2166                     $rawline =~ /^\+\s*        \s*/) {
2167                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2168                         $rpt_cleaners = 1;
2169                         if (ERROR("CODE_INDENT",
2170                                   "code indent should use tabs where possible\n" . $herevet) &&
2171                             $fix) {
2172                                 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2173                         }
2174                 }
2175
2176 # check for space before tabs.
2177                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2178                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2179                         if (WARN("SPACE_BEFORE_TAB",
2180                                 "please, no space before tabs\n" . $herevet) &&
2181                             $fix) {
2182                                 while ($fixed[$linenr - 1] =~
2183                                            s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2184                                 while ($fixed[$linenr - 1] =~
2185                                            s/(^\+.*) +\t/$1\t/) {}
2186                         }
2187                 }
2188
2189 # check for && or || at the start of a line
2190                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2191                         CHK("LOGICAL_CONTINUATIONS",
2192                             "Logical continuations should be on the previous line\n" . $hereprev);
2193                 }
2194
2195 # check multi-line statement indentation matches previous line
2196                 if ($^V && $^V ge 5.10.0 &&
2197                     $prevline =~ /^\+(\t*)(if \(|$Ident\().*(\&\&|\|\||,)\s*$/) {
2198                         $prevline =~ /^\+(\t*)(.*)$/;
2199                         my $oldindent = $1;
2200                         my $rest = $2;
2201
2202                         my $pos = pos_last_openparen($rest);
2203                         if ($pos >= 0) {
2204                                 $line =~ /^(\+| )([ \t]*)/;
2205                                 my $newindent = $2;
2206
2207                                 my $goodtabindent = $oldindent .
2208                                         "\t" x ($pos / 8) .
2209                                         " "  x ($pos % 8);
2210                                 my $goodspaceindent = $oldindent . " "  x $pos;
2211
2212                                 if ($newindent ne $goodtabindent &&
2213                                     $newindent ne $goodspaceindent) {
2214
2215                                         if (CHK("PARENTHESIS_ALIGNMENT",
2216                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
2217                                             $fix && $line =~ /^\+/) {
2218                                                 $fixed[$linenr - 1] =~
2219                                                     s/^\+[ \t]*/\+$goodtabindent/;
2220                                         }
2221                                 }
2222                         }
2223                 }
2224
2225                 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
2226                         if (CHK("SPACING",
2227                                 "No space is necessary after a cast\n" . $hereprev) &&
2228                             $fix) {
2229                                 $fixed[$linenr - 1] =~
2230                                     s/^(\+.*\*[ \t]*\))[ \t]+/$1/;
2231                         }
2232                 }
2233
2234                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2235                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2236                     $rawline =~ /^\+[ \t]*\*/ &&
2237                     $realline > 2) {
2238                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2239                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2240                 }
2241
2242                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2243                     $prevrawline =~ /^\+[ \t]*\/\*/ &&          #starting /*
2244                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
2245                     $rawline =~ /^\+/ &&                        #line is new
2246                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
2247                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2248                              "networking block comments start with * on subsequent lines\n" . $hereprev);
2249                 }
2250
2251                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2252                     $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
2253                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
2254                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
2255                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
2256                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2257                              "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2258                 }
2259
2260 # check for spaces at the beginning of a line.
2261 # Exceptions:
2262 #  1) within comments
2263 #  2) indented preprocessor commands
2264 #  3) hanging labels
2265                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2266                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2267                         if (WARN("LEADING_SPACE",
2268                                  "please, no spaces at the start of a line\n" . $herevet) &&
2269                             $fix) {
2270                                 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2271                         }
2272                 }
2273
2274 # check we are in a valid C source file if not then ignore this hunk
2275                 next if ($realfile !~ /\.(h|c)$/);
2276
2277 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2278                 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2279                         WARN("CONFIG_EXPERIMENTAL",
2280                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2281                 }
2282
2283 # check for RCS/CVS revision markers
2284                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2285                         WARN("CVS_KEYWORD",
2286                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2287                 }
2288
2289 # Blackfin: don't use __builtin_bfin_[cs]sync
2290                 if ($line =~ /__builtin_bfin_csync/) {
2291                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2292                         ERROR("CSYNC",
2293                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2294                 }
2295                 if ($line =~ /__builtin_bfin_ssync/) {
2296                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2297                         ERROR("SSYNC",
2298                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2299                 }
2300
2301 # check for old HOTPLUG __dev<foo> section markings
2302                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2303                         WARN("HOTPLUG_SECTION",
2304                              "Using $1 is unnecessary\n" . $herecurr);
2305                 }
2306
2307 # Check for potential 'bare' types
2308                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2309                     $realline_next);
2310 #print "LINE<$line>\n";
2311                 if ($linenr >= $suppress_statement &&
2312                     $realcnt && $sline =~ /.\s*\S/) {
2313                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2314                                 ctx_statement_block($linenr, $realcnt, 0);
2315                         $stat =~ s/\n./\n /g;
2316                         $cond =~ s/\n./\n /g;
2317
2318 #print "linenr<$linenr> <$stat>\n";
2319                         # If this statement has no statement boundaries within
2320                         # it there is no point in retrying a statement scan
2321                         # until we hit end of it.
2322                         my $frag = $stat; $frag =~ s/;+\s*$//;
2323                         if ($frag !~ /(?:{|;)/) {
2324 #print "skip<$line_nr_next>\n";
2325                                 $suppress_statement = $line_nr_next;
2326                         }
2327
2328                         # Find the real next line.
2329                         $realline_next = $line_nr_next;
2330                         if (defined $realline_next &&
2331                             (!defined $lines[$realline_next - 1] ||
2332                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2333                                 $realline_next++;
2334                         }
2335
2336                         my $s = $stat;
2337                         $s =~ s/{.*$//s;
2338
2339                         # Ignore goto labels.
2340                         if ($s =~ /$Ident:\*$/s) {
2341
2342                         # Ignore functions being called
2343                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2344
2345                         } elsif ($s =~ /^.\s*else\b/s) {
2346
2347                         # declarations always start with types
2348                         } 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) {
2349                                 my $type = $1;
2350                                 $type =~ s/\s+/ /g;
2351                                 possible($type, "A:" . $s);
2352
2353                         # definitions in global scope can only start with types
2354                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2355                                 possible($1, "B:" . $s);
2356                         }
2357
2358                         # any (foo ... *) is a pointer cast, and foo is a type
2359                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2360                                 possible($1, "C:" . $s);
2361                         }
2362
2363                         # Check for any sort of function declaration.
2364                         # int foo(something bar, other baz);
2365                         # void (*store_gdt)(x86_descr_ptr *);
2366                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2367                                 my ($name_len) = length($1);
2368
2369                                 my $ctx = $s;
2370                                 substr($ctx, 0, $name_len + 1, '');
2371                                 $ctx =~ s/\)[^\)]*$//;
2372
2373                                 for my $arg (split(/\s*,\s*/, $ctx)) {
2374                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2375
2376                                                 possible($1, "D:" . $s);
2377                                         }
2378                                 }
2379                         }
2380
2381                 }
2382
2383 #
2384 # Checks which may be anchored in the context.
2385 #
2386
2387 # Check for switch () and associated case and default
2388 # statements should be at the same indent.
2389                 if ($line=~/\bswitch\s*\(.*\)/) {
2390                         my $err = '';
2391                         my $sep = '';
2392                         my @ctx = ctx_block_outer($linenr, $realcnt);
2393                         shift(@ctx);
2394                         for my $ctx (@ctx) {
2395                                 my ($clen, $cindent) = line_stats($ctx);
2396                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2397                                                         $indent != $cindent) {
2398                                         $err .= "$sep$ctx\n";
2399                                         $sep = '';
2400                                 } else {
2401                                         $sep = "[...]\n";
2402                                 }
2403                         }
2404                         if ($err ne '') {
2405                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
2406                                       "switch and case should be at the same indent\n$hereline$err");
2407                         }
2408                 }
2409
2410 # if/while/etc brace do not go on next line, unless defining a do while loop,
2411 # or if that brace on the next line is for something else
2412                 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2413                         my $pre_ctx = "$1$2";
2414
2415                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2416
2417                         if ($line =~ /^\+\t{6,}/) {
2418                                 WARN("DEEP_INDENTATION",
2419                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
2420                         }
2421
2422                         my $ctx_cnt = $realcnt - $#ctx - 1;
2423                         my $ctx = join("\n", @ctx);
2424
2425                         my $ctx_ln = $linenr;
2426                         my $ctx_skip = $realcnt;
2427
2428                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2429                                         defined $lines[$ctx_ln - 1] &&
2430                                         $lines[$ctx_ln - 1] =~ /^-/)) {
2431                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2432                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2433                                 $ctx_ln++;
2434                         }
2435
2436                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2437                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2438
2439                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2440                                 ERROR("OPEN_BRACE",
2441                                       "that open brace { should be on the previous line\n" .
2442                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2443                         }
2444                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2445                             $ctx =~ /\)\s*\;\s*$/ &&
2446                             defined $lines[$ctx_ln - 1])
2447                         {
2448                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2449                                 if ($nindent > $indent) {
2450                                         WARN("TRAILING_SEMICOLON",
2451                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
2452                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2453                                 }
2454                         }
2455                 }
2456
2457 # Check relative indent for conditionals and blocks.
2458                 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2459                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2460                                 ctx_statement_block($linenr, $realcnt, 0)
2461                                         if (!defined $stat);
2462                         my ($s, $c) = ($stat, $cond);
2463
2464                         substr($s, 0, length($c), '');
2465
2466                         # Make sure we remove the line prefixes as we have
2467                         # none on the first line, and are going to readd them
2468                         # where necessary.
2469                         $s =~ s/\n./\n/gs;
2470
2471                         # Find out how long the conditional actually is.
2472                         my @newlines = ($c =~ /\n/gs);
2473                         my $cond_lines = 1 + $#newlines;
2474
2475                         # We want to check the first line inside the block
2476                         # starting at the end of the conditional, so remove:
2477                         #  1) any blank line termination
2478                         #  2) any opening brace { on end of the line
2479                         #  3) any do (...) {
2480                         my $continuation = 0;
2481                         my $check = 0;
2482                         $s =~ s/^.*\bdo\b//;
2483                         $s =~ s/^\s*{//;
2484                         if ($s =~ s/^\s*\\//) {
2485                                 $continuation = 1;
2486                         }
2487                         if ($s =~ s/^\s*?\n//) {
2488                                 $check = 1;
2489                                 $cond_lines++;
2490                         }
2491
2492                         # Also ignore a loop construct at the end of a
2493                         # preprocessor statement.
2494                         if (($prevline =~ /^.\s*#\s*define\s/ ||
2495                             $prevline =~ /\\\s*$/) && $continuation == 0) {
2496                                 $check = 0;
2497                         }
2498
2499                         my $cond_ptr = -1;
2500                         $continuation = 0;
2501                         while ($cond_ptr != $cond_lines) {
2502                                 $cond_ptr = $cond_lines;
2503
2504                                 # If we see an #else/#elif then the code
2505                                 # is not linear.
2506                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2507                                         $check = 0;
2508                                 }
2509
2510                                 # Ignore:
2511                                 #  1) blank lines, they should be at 0,
2512                                 #  2) preprocessor lines, and
2513                                 #  3) labels.
2514                                 if ($continuation ||
2515                                     $s =~ /^\s*?\n/ ||
2516                                     $s =~ /^\s*#\s*?/ ||
2517                                     $s =~ /^\s*$Ident\s*:/) {
2518                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2519                                         if ($s =~ s/^.*?\n//) {
2520                                                 $cond_lines++;
2521                                         }
2522                                 }
2523                         }
2524
2525                         my (undef, $sindent) = line_stats("+" . $s);
2526                         my $stat_real = raw_line($linenr, $cond_lines);
2527
2528                         # Check if either of these lines are modified, else
2529                         # this is not this patch's fault.
2530                         if (!defined($stat_real) ||
2531                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2532                                 $check = 0;
2533                         }
2534                         if (defined($stat_real) && $cond_lines > 1) {
2535                                 $stat_real = "[...]\n$stat_real";
2536                         }
2537
2538                         #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";
2539
2540                         if ($check && (($sindent % 8) != 0 ||
2541                             ($sindent <= $indent && $s ne ''))) {
2542                                 WARN("SUSPECT_CODE_INDENT",
2543                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2544                         }
2545                 }
2546
2547                 # Track the 'values' across context and added lines.
2548                 my $opline = $line; $opline =~ s/^./ /;
2549                 my ($curr_values, $curr_vars) =
2550                                 annotate_values($opline . "\n", $prev_values);
2551                 $curr_values = $prev_values . $curr_values;
2552                 if ($dbg_values) {
2553                         my $outline = $opline; $outline =~ s/\t/ /g;
2554                         print "$linenr > .$outline\n";
2555                         print "$linenr > $curr_values\n";
2556                         print "$linenr >  $curr_vars\n";
2557                 }
2558                 $prev_values = substr($curr_values, -1);
2559
2560 #ignore lines not being added
2561                 next if ($line =~ /^[^\+]/);
2562
2563 # TEST: allow direct testing of the type matcher.
2564                 if ($dbg_type) {
2565                         if ($line =~ /^.\s*$Declare\s*$/) {
2566                                 ERROR("TEST_TYPE",
2567                                       "TEST: is type\n" . $herecurr);
2568                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2569                                 ERROR("TEST_NOT_TYPE",
2570                                       "TEST: is not type ($1 is)\n". $herecurr);
2571                         }
2572                         next;
2573                 }
2574 # TEST: allow direct testing of the attribute matcher.
2575                 if ($dbg_attr) {
2576                         if ($line =~ /^.\s*$Modifier\s*$/) {
2577                                 ERROR("TEST_ATTR",
2578                                       "TEST: is attr\n" . $herecurr);
2579                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2580                                 ERROR("TEST_NOT_ATTR",
2581                                       "TEST: is not attr ($1 is)\n". $herecurr);
2582                         }
2583                         next;
2584                 }
2585
2586 # check for initialisation to aggregates open brace on the next line
2587                 if ($line =~ /^.\s*{/ &&
2588                     $prevline =~ /(?:^|[^=])=\s*$/) {
2589                         ERROR("OPEN_BRACE",
2590                               "that open brace { should be on the previous line\n" . $hereprev);
2591                 }
2592
2593 #
2594 # Checks which are anchored on the added line.
2595 #
2596
2597 # check for malformed paths in #include statements (uses RAW line)
2598                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2599                         my $path = $1;
2600                         if ($path =~ m{//}) {
2601                                 ERROR("MALFORMED_INCLUDE",
2602                                       "malformed #include filename\n" . $herecurr);
2603                         }
2604                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2605                                 ERROR("UAPI_INCLUDE",
2606                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2607                         }
2608                 }
2609
2610 # no C99 // comments
2611                 if ($line =~ m{//}) {
2612                         if (ERROR("C99_COMMENTS",
2613                                   "do not use C99 // comments\n" . $herecurr) &&
2614                             $fix) {
2615                                 my $line = $fixed[$linenr - 1];
2616                                 if ($line =~ /\/\/(.*)$/) {
2617                                         my $comment = trim($1);
2618                                         $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2619                                 }
2620                         }
2621                 }
2622                 # Remove C99 comments.
2623                 $line =~ s@//.*@@;
2624                 $opline =~ s@//.*@@;
2625
2626 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2627 # the whole statement.
2628 #print "APW <$lines[$realline_next - 1]>\n";
2629                 if (defined $realline_next &&
2630                     exists $lines[$realline_next - 1] &&
2631                     !defined $suppress_export{$realline_next} &&
2632                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2633                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2634                         # Handle definitions which produce identifiers with
2635                         # a prefix:
2636                         #   XXX(foo);
2637                         #   EXPORT_SYMBOL(something_foo);
2638                         my $name = $1;
2639                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
2640                             $name =~ /^${Ident}_$2/) {
2641 #print "FOO C name<$name>\n";
2642                                 $suppress_export{$realline_next} = 1;
2643
2644                         } elsif ($stat !~ /(?:
2645                                 \n.}\s*$|
2646                                 ^.DEFINE_$Ident\(\Q$name\E\)|
2647                                 ^.DECLARE_$Ident\(\Q$name\E\)|
2648                                 ^.LIST_HEAD\(\Q$name\E\)|
2649                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2650                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2651                             )/x) {
2652 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2653                                 $suppress_export{$realline_next} = 2;
2654                         } else {
2655                                 $suppress_export{$realline_next} = 1;
2656                         }
2657                 }
2658                 if (!defined $suppress_export{$linenr} &&
2659                     $prevline =~ /^.\s*$/ &&
2660                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2661                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2662 #print "FOO B <$lines[$linenr - 1]>\n";
2663                         $suppress_export{$linenr} = 2;
2664                 }
2665                 if (defined $suppress_export{$linenr} &&
2666                     $suppress_export{$linenr} == 2) {
2667                         WARN("EXPORT_SYMBOL",
2668                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2669                 }
2670
2671 # check for global initialisers.
2672                 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2673                         if (ERROR("GLOBAL_INITIALISERS",
2674                                   "do not initialise globals to 0 or NULL\n" .
2675                                       $herecurr) &&
2676                             $fix) {
2677                                 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2678                         }
2679                 }
2680 # check for static initialisers.
2681                 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2682                         if (ERROR("INITIALISED_STATIC",
2683                                   "do not initialise statics to 0 or NULL\n" .
2684                                       $herecurr) &&
2685                             $fix) {
2686                                 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2687                         }
2688                 }
2689
2690 # check for static const char * arrays.
2691                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2692                         WARN("STATIC_CONST_CHAR_ARRAY",
2693                              "static const char * array should probably be static const char * const\n" .
2694                                 $herecurr);
2695                }
2696
2697 # check for static char foo[] = "bar" declarations.
2698                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2699                         WARN("STATIC_CONST_CHAR_ARRAY",
2700                              "static char array declaration should probably be static const char\n" .
2701                                 $herecurr);
2702                }
2703
2704 # check for non-global char *foo[] = {"bar", ...} declarations.
2705                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
2706                         WARN("STATIC_CONST_CHAR_ARRAY",
2707                              "char * array declaration might be better as static const\n" .
2708                                 $herecurr);
2709                }
2710
2711 # check for function declarations without arguments like "int foo()"
2712                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2713                         if (ERROR("FUNCTION_WITHOUT_ARGS",
2714                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2715                             $fix) {
2716                                 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2717                         }
2718                 }
2719
2720 # check for uses of DEFINE_PCI_DEVICE_TABLE
2721                 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2722                         if (WARN("DEFINE_PCI_DEVICE_TABLE",
2723                                  "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2724                             $fix) {
2725                                 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2726                         }
2727                 }
2728
2729 # check for new typedefs, only function parameters and sparse annotations
2730 # make sense.
2731                 if ($line =~ /\btypedef\s/ &&
2732                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2733                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2734                     $line !~ /\b$typeTypedefs\b/ &&
2735                     $line !~ /\b__bitwise(?:__|)\b/) {
2736                         WARN("NEW_TYPEDEFS",
2737                              "do not add new typedefs\n" . $herecurr);
2738                 }
2739
2740 # * goes on variable not on type
2741                 # (char*[ const])
2742                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2743                         #print "AA<$1>\n";
2744                         my ($ident, $from, $to) = ($1, $2, $2);
2745
2746                         # Should start with a space.
2747                         $to =~ s/^(\S)/ $1/;
2748                         # Should not end with a space.
2749                         $to =~ s/\s+$//;
2750                         # '*'s should not have spaces between.
2751                         while ($to =~ s/\*\s+\*/\*\*/) {
2752                         }
2753
2754 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
2755                         if ($from ne $to) {
2756                                 if (ERROR("POINTER_LOCATION",
2757                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
2758                                     $fix) {
2759                                         my $sub_from = $ident;
2760                                         my $sub_to = $ident;
2761                                         $sub_to =~ s/\Q$from\E/$to/;
2762                                         $fixed[$linenr - 1] =~
2763                                             s@\Q$sub_from\E@$sub_to@;
2764                                 }
2765                         }
2766                 }
2767                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2768                         #print "BB<$1>\n";
2769                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
2770
2771                         # Should start with a space.
2772                         $to =~ s/^(\S)/ $1/;
2773                         # Should not end with a space.
2774                         $to =~ s/\s+$//;
2775                         # '*'s should not have spaces between.
2776                         while ($to =~ s/\*\s+\*/\*\*/) {
2777                         }
2778                         # Modifiers should have spaces.
2779                         $to =~ s/(\b$Modifier$)/$1 /;
2780
2781 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
2782                         if ($from ne $to && $ident !~ /^$Modifier$/) {
2783                                 if (ERROR("POINTER_LOCATION",
2784                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
2785                                     $fix) {
2786
2787                                         my $sub_from = $match;
2788                                         my $sub_to = $match;
2789                                         $sub_to =~ s/\Q$from\E/$to/;
2790                                         $fixed[$linenr - 1] =~
2791                                             s@\Q$sub_from\E@$sub_to@;
2792                                 }
2793                         }
2794                 }
2795
2796 # # no BUG() or BUG_ON()
2797 #               if ($line =~ /\b(BUG|BUG_ON)\b/) {
2798 #                       print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2799 #                       print "$herecurr";
2800 #                       $clean = 0;
2801 #               }
2802
2803                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2804                         WARN("LINUX_VERSION_CODE",
2805                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2806                 }
2807
2808 # check for uses of printk_ratelimit
2809                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2810                         WARN("PRINTK_RATELIMITED",
2811 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2812                 }
2813
2814 # printk should use KERN_* levels.  Note that follow on printk's on the
2815 # same line do not need a level, so we use the current block context
2816 # to try and find and validate the current printk.  In summary the current
2817 # printk includes all preceding printk's which have no newline on the end.
2818 # we assume the first bad printk is the one to report.
2819                 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2820                         my $ok = 0;
2821                         for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2822                                 #print "CHECK<$lines[$ln - 1]\n";
2823                                 # we have a preceding printk if it ends
2824                                 # with "\n" ignore it, else it is to blame
2825                                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2826                                         if ($rawlines[$ln - 1] !~ m{\\n"}) {
2827                                                 $ok = 1;
2828                                         }
2829                                         last;
2830                                 }
2831                         }
2832                         if ($ok == 0) {
2833                                 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2834                                      "printk() should include KERN_ facility level\n" . $herecurr);
2835                         }
2836                 }
2837
2838                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2839                         my $orig = $1;
2840                         my $level = lc($orig);
2841                         $level = "warn" if ($level eq "warning");
2842                         my $level2 = $level;
2843                         $level2 = "dbg" if ($level eq "debug");
2844                         WARN("PREFER_PR_LEVEL",
2845                              "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
2846                 }
2847
2848                 if ($line =~ /\bpr_warning\s*\(/) {
2849                         if (WARN("PREFER_PR_LEVEL",
2850                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2851                             $fix) {
2852                                 $fixed[$linenr - 1] =~
2853                                     s/\bpr_warning\b/pr_warn/;
2854                         }
2855                 }
2856
2857                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2858                         my $orig = $1;
2859                         my $level = lc($orig);
2860                         $level = "warn" if ($level eq "warning");
2861                         $level = "dbg" if ($level eq "debug");
2862                         WARN("PREFER_DEV_LEVEL",
2863                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2864                 }
2865
2866 # function brace can't be on same line, except for #defines of do while,
2867 # or if closed on same line
2868                 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2869                     !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2870                         ERROR("OPEN_BRACE",
2871                               "open brace '{' following function declarations go on the next line\n" . $herecurr);
2872                 }
2873
2874 # open braces for enum, union and struct go on the same line.
2875                 if ($line =~ /^.\s*{/ &&
2876                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2877                         ERROR("OPEN_BRACE",
2878                               "open brace '{' following $1 go on the same line\n" . $hereprev);
2879                 }
2880
2881 # missing space after union, struct or enum definition
2882                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2883                         if (WARN("SPACING",
2884                                  "missing space after $1 definition\n" . $herecurr) &&
2885                             $fix) {
2886                                 $fixed[$linenr - 1] =~
2887                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
2888                         }
2889                 }
2890
2891 # Function pointer declarations
2892 # check spacing between type, funcptr, and args
2893 # canonical declaration is "type (*funcptr)(args...)"
2894                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
2895                         my $declare = $1;
2896                         my $pre_pointer_space = $2;
2897                         my $post_pointer_space = $3;
2898                         my $funcname = $4;
2899                         my $post_funcname_space = $5;
2900                         my $pre_args_space = $6;
2901
2902 # the $Declare variable will capture all spaces after the type
2903 # so check it for a missing trailing missing space but pointer return types
2904 # don't need a space so don't warn for those.
2905                         my $post_declare_space = "";
2906                         if ($declare =~ /(\s+)$/) {
2907                                 $post_declare_space = $1;
2908                                 $declare = rtrim($declare);
2909                         }
2910                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
2911                                 WARN("SPACING",
2912                                      "missing space after return type\n" . $herecurr);
2913                                 $post_declare_space = " ";
2914                         }
2915
2916 # unnecessary space "type  (*funcptr)(args...)"
2917 # This test is not currently implemented because these declarations are
2918 # equivalent to
2919 #       int  foo(int bar, ...)
2920 # and this is form shouldn't/doesn't generate a checkpatch warning.
2921 #
2922 #                       elsif ($declare =~ /\s{2,}$/) {
2923 #                               WARN("SPACING",
2924 #                                    "Multiple spaces after return type\n" . $herecurr);
2925 #                       }
2926
2927 # unnecessary space "type ( *funcptr)(args...)"
2928                         if (defined $pre_pointer_space &&
2929                             $pre_pointer_space =~ /^\s/) {
2930                                 WARN("SPACING",
2931                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
2932                         }
2933
2934 # unnecessary space "type (* funcptr)(args...)"
2935                         if (defined $post_pointer_space &&
2936                             $post_pointer_space =~ /^\s/) {
2937                                 WARN("SPACING",
2938                                      "Unnecessary space before function pointer name\n" . $herecurr);
2939                         }
2940
2941 # unnecessary space "type (*funcptr )(args...)"
2942                         if (defined $post_funcname_space &&
2943                             $post_funcname_space =~ /^\s/) {
2944                                 WARN("SPACING",
2945                                      "Unnecessary space after function pointer name\n" . $herecurr);
2946                         }
2947
2948 # unnecessary space "type (*funcptr) (args...)"
2949                         if (defined $pre_args_space &&
2950                             $pre_args_space =~ /^\s/) {
2951                                 WARN("SPACING",
2952                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
2953                         }
2954
2955                         if (show_type("SPACING") && $fix) {
2956                                 $fixed[$linenr - 1] =~
2957                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
2958                         }
2959                 }
2960
2961 # check for spacing round square brackets; allowed:
2962 #  1. with a type on the left -- int [] a;
2963 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2964 #  3. inside a curly brace -- = { [0...10] = 5 }
2965                 while ($line =~ /(.*?\s)\[/g) {
2966                         my ($where, $prefix) = ($-[1], $1);
2967                         if ($prefix !~ /$Type\s+$/ &&
2968                             ($where != 0 || $prefix !~ /^.\s+$/) &&
2969                             $prefix !~ /[{,]\s+$/) {
2970                                 if (ERROR("BRACKET_SPACE",
2971                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
2972                                     $fix) {
2973                                     $fixed[$linenr - 1] =~
2974                                         s/^(\+.*?)\s+\[/$1\[/;
2975                                 }
2976                         }
2977                 }
2978
2979 # check for spaces between functions and their parentheses.
2980                 while ($line =~ /($Ident)\s+\(/g) {
2981                         my $name = $1;
2982                         my $ctx_before = substr($line, 0, $-[1]);
2983                         my $ctx = "$ctx_before$name";
2984
2985                         # Ignore those directives where spaces _are_ permitted.
2986                         if ($name =~ /^(?:
2987                                 if|for|while|switch|return|case|
2988                                 volatile|__volatile__|
2989                                 __attribute__|format|__extension__|
2990                                 asm|__asm__)$/x)
2991                         {
2992                         # cpp #define statements have non-optional spaces, ie
2993                         # if there is a space between the name and the open
2994                         # parenthesis it is simply not a parameter group.
2995                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2996
2997                         # cpp #elif statement condition may start with a (
2998                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2999
3000                         # If this whole things ends with a type its most
3001                         # likely a typedef for a function.
3002                         } elsif ($ctx =~ /$Type$/) {
3003
3004                         } else {
3005                                 if (WARN("SPACING",
3006                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3007                                              $fix) {
3008                                         $fixed[$linenr - 1] =~
3009                                             s/\b$name\s+\(/$name\(/;
3010                                 }
3011                         }
3012                 }
3013
3014 # Check operator spacing.
3015                 if (!($line=~/\#\s*include/)) {
3016                         my $fixed_line = "";
3017                         my $line_fixed = 0;
3018
3019                         my $ops = qr{
3020                                 <<=|>>=|<=|>=|==|!=|
3021                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3022                                 =>|->|<<|>>|<|>|=|!|~|
3023                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3024                                 \?:|\?|:
3025                         }x;
3026                         my @elements = split(/($ops|;)/, $opline);
3027
3028 ##                      print("element count: <" . $#elements . ">\n");
3029 ##                      foreach my $el (@elements) {
3030 ##                              print("el: <$el>\n");
3031 ##                      }
3032
3033                         my @fix_elements = ();
3034                         my $off = 0;
3035
3036                         foreach my $el (@elements) {
3037                                 push(@fix_elements, substr($rawline, $off, length($el)));
3038                                 $off += length($el);
3039                         }
3040
3041                         $off = 0;
3042
3043                         my $blank = copy_spacing($opline);
3044                         my $last_after = -1;
3045
3046                         for (my $n = 0; $n < $#elements; $n += 2) {
3047
3048                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3049
3050 ##                              print("n: <$n> good: <$good>\n");
3051
3052                                 $off += length($elements[$n]);
3053
3054                                 # Pick up the preceding and succeeding characters.
3055                                 my $ca = substr($opline, 0, $off);
3056                                 my $cc = '';
3057                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3058                                         $cc = substr($opline, $off + length($elements[$n + 1]));
3059                                 }
3060                                 my $cb = "$ca$;$cc";
3061
3062                                 my $a = '';
3063                                 $a = 'V' if ($elements[$n] ne '');
3064                                 $a = 'W' if ($elements[$n] =~ /\s$/);
3065                                 $a = 'C' if ($elements[$n] =~ /$;$/);
3066                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3067                                 $a = 'O' if ($elements[$n] eq '');
3068                                 $a = 'E' if ($ca =~ /^\s*$/);
3069
3070                                 my $op = $elements[$n + 1];
3071
3072                                 my $c = '';
3073                                 if (defined $elements[$n + 2]) {
3074                                         $c = 'V' if ($elements[$n + 2] ne '');
3075                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3076                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3077                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3078                                         $c = 'O' if ($elements[$n + 2] eq '');
3079                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3080                                 } else {
3081                                         $c = 'E';
3082                                 }
3083
3084                                 my $ctx = "${a}x${c}";
3085
3086                                 my $at = "(ctx:$ctx)";
3087
3088                                 my $ptr = substr($blank, 0, $off) . "^";
3089                                 my $hereptr = "$hereline$ptr\n";
3090
3091                                 # Pull out the value of this operator.
3092                                 my $op_type = substr($curr_values, $off + 1, 1);
3093
3094                                 # Get the full operator variant.
3095                                 my $opv = $op . substr($curr_vars, $off, 1);
3096
3097                                 # Ignore operators passed as parameters.
3098                                 if ($op_type ne 'V' &&
3099                                     $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3100
3101 #                               # Ignore comments
3102 #                               } elsif ($op =~ /^$;+$/) {
3103
3104                                 # ; should have either the end of line or a space or \ after it
3105                                 } elsif ($op eq ';') {
3106                                         if ($ctx !~ /.x[WEBC]/ &&
3107                                             $cc !~ /^\\/ && $cc !~ /^;/) {
3108                                                 if (ERROR("SPACING",
3109                                                           "space required after that '$op' $at\n" . $hereptr)) {
3110                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3111                                                         $line_fixed = 1;
3112                                                 }
3113                                         }
3114
3115                                 # // is a comment
3116                                 } elsif ($op eq '//') {
3117
3118                                 # No spaces for:
3119                                 #   ->
3120                                 #   :   when part of a bitfield
3121                                 } elsif ($op eq '->' || $opv eq ':B') {
3122                                         if ($ctx =~ /Wx.|.xW/) {
3123                                                 if (ERROR("SPACING",
3124                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3125                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3126                                                         if (defined $fix_elements[$n + 2]) {
3127                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3128                                                         }
3129                                                         $line_fixed = 1;
3130                                                 }
3131                                         }
3132
3133                                 # , must have a space on the right.
3134                                 } elsif ($op eq ',') {
3135                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3136                                                 if (ERROR("SPACING",
3137                                                           "space required after that '$op' $at\n" . $hereptr)) {
3138                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3139                                                         $line_fixed = 1;
3140                                                         $last_after = $n;
3141                                                 }
3142                                         }
3143
3144                                 # '*' as part of a type definition -- reported already.
3145                                 } elsif ($opv eq '*_') {
3146                                         #warn "'*' is part of type\n";
3147
3148                                 # unary operators should have a space before and
3149                                 # none after.  May be left adjacent to another
3150                                 # unary operator, or a cast
3151                                 } elsif ($op eq '!' || $op eq '~' ||
3152                                          $opv eq '*U' || $opv eq '-U' ||
3153                                          $opv eq '&U' || $opv eq '&&U') {
3154                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3155                                                 if (ERROR("SPACING",
3156                                                           "space required before that '$op' $at\n" . $hereptr)) {
3157                                                         if ($n != $last_after + 2) {
3158                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3159                                                                 $line_fixed = 1;
3160                                                         }
3161                                                 }
3162                                         }
3163                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3164                                                 # A unary '*' may be const
3165
3166                                         } elsif ($ctx =~ /.xW/) {
3167                                                 if (ERROR("SPACING",
3168                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3169                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3170                                                         if (defined $fix_elements[$n + 2]) {
3171                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3172                                                         }
3173                                                         $line_fixed = 1;
3174                                                 }
3175                                         }
3176
3177                                 # unary ++ and unary -- are allowed no space on one side.
3178                                 } elsif ($op eq '++' or $op eq '--') {
3179                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3180                                                 if (ERROR("SPACING",
3181                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
3182                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3183                                                         $line_fixed = 1;
3184                                                 }
3185                                         }
3186                                         if ($ctx =~ /Wx[BE]/ ||
3187                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3188                                                 if (ERROR("SPACING",
3189                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3190                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3191                                                         $line_fixed = 1;
3192                                                 }
3193                                         }
3194                                         if ($ctx =~ /ExW/) {
3195                                                 if (ERROR("SPACING",
3196                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3197                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3198                                                         if (defined $fix_elements[$n + 2]) {
3199                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3200                                                         }
3201                                                         $line_fixed = 1;
3202                                                 }
3203                                         }
3204
3205                                 # << and >> may either have or not have spaces both sides
3206                                 } elsif ($op eq '<<' or $op eq '>>' or
3207                                          $op eq '&' or $op eq '^' or $op eq '|' or
3208                                          $op eq '+' or $op eq '-' or
3209                                          $op eq '*' or $op eq '/' or
3210                                          $op eq '%')
3211                                 {
3212                                         if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3213                                                 if (ERROR("SPACING",
3214                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
3215                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3216                                                         if (defined $fix_elements[$n + 2]) {
3217                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3218                                                         }
3219                                                         $line_fixed = 1;
3220                                                 }
3221                                         }
3222
3223                                 # A colon needs no spaces before when it is
3224                                 # terminating a case value or a label.
3225                                 } elsif ($opv eq ':C' || $opv eq ':L') {
3226                                         if ($ctx =~ /Wx./) {
3227                                                 if (ERROR("SPACING",
3228                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3229                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3230                                                         $line_fixed = 1;
3231                                                 }
3232                                         }
3233
3234                                 # All the others need spaces both sides.
3235                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3236                                         my $ok = 0;
3237
3238                                         # Ignore email addresses <foo@bar>
3239                                         if (($op eq '<' &&
3240                                              $cc =~ /^\S+\@\S+>/) ||
3241                                             ($op eq '>' &&
3242                                              $ca =~ /<\S+\@\S+$/))
3243                                         {
3244                                                 $ok = 1;
3245                                         }
3246
3247                                         # messages are ERROR, but ?: are CHK
3248                                         if ($ok == 0) {
3249                                                 my $msg_type = \&ERROR;
3250                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3251
3252                                                 if (&{$msg_type}("SPACING",
3253                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {
3254                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3255                                                         if (defined $fix_elements[$n + 2]) {
3256                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3257                                                         }
3258                                                         $line_fixed = 1;
3259                                                 }
3260                                         }
3261                                 }
3262                                 $off += length($elements[$n + 1]);
3263
3264 ##                              print("n: <$n> GOOD: <$good>\n");
3265
3266                                 $fixed_line = $fixed_line . $good;
3267                         }
3268
3269                         if (($#elements % 2) == 0) {
3270                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
3271                         }
3272
3273                         if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3274                                 $fixed[$linenr - 1] = $fixed_line;
3275                         }
3276
3277
3278                 }
3279
3280 # check for whitespace before a non-naked semicolon
3281                 if ($line =~ /^\+.*\S\s+;\s*$/) {
3282                         if (WARN("SPACING",
3283                                  "space prohibited before semicolon\n" . $herecurr) &&
3284                             $fix) {
3285                                 1 while $fixed[$linenr - 1] =~
3286                                     s/^(\+.*\S)\s+;/$1;/;
3287                         }
3288                 }
3289
3290 # check for multiple assignments
3291                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3292                         CHK("MULTIPLE_ASSIGNMENTS",
3293                             "multiple assignments should be avoided\n" . $herecurr);
3294                 }
3295
3296 ## # check for multiple declarations, allowing for a function declaration
3297 ## # continuation.
3298 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3299 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3300 ##
3301 ##                      # Remove any bracketed sections to ensure we do not
3302 ##                      # falsly report the parameters of functions.
3303 ##                      my $ln = $line;
3304 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
3305 ##                      }
3306 ##                      if ($ln =~ /,/) {
3307 ##                              WARN("MULTIPLE_DECLARATION",
3308 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
3309 ##                      }
3310 ##              }
3311
3312 #need space before brace following if, while, etc
3313                 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3314                     $line =~ /do{/) {
3315                         if (ERROR("SPACING",
3316                                   "space required before the open brace '{'\n" . $herecurr) &&
3317                             $fix) {
3318                                 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3319                         }
3320                 }
3321
3322 ## # check for blank lines before declarations
3323 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3324 ##                  $prevrawline =~ /^.\s*$/) {
3325 ##                      WARN("SPACING",
3326 ##                           "No blank lines before declarations\n" . $hereprev);
3327 ##              }
3328 ##
3329
3330 # closing brace should have a space following it when it has anything
3331 # on the line
3332                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3333                         if (ERROR("SPACING",
3334                                   "space required after that close brace '}'\n" . $herecurr) &&
3335                             $fix) {
3336                                 $fixed[$linenr - 1] =~
3337                                     s/}((?!(?:,|;|\)))\S)/} $1/;
3338                         }
3339                 }
3340
3341 # check spacing on square brackets
3342                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3343                         if (ERROR("SPACING",
3344                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
3345                             $fix) {
3346                                 $fixed[$linenr - 1] =~
3347                                     s/\[\s+/\[/;
3348                         }
3349                 }
3350                 if ($line =~ /\s\]/) {
3351                         if (ERROR("SPACING",
3352                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3353                             $fix) {
3354                                 $fixed[$linenr - 1] =~
3355                                     s/\s+\]/\]/;
3356                         }
3357                 }
3358
3359 # check spacing on parentheses
3360                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3361                     $line !~ /for\s*\(\s+;/) {
3362                         if (ERROR("SPACING",
3363                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3364                             $fix) {
3365                                 $fixed[$linenr - 1] =~
3366                                     s/\(\s+/\(/;
3367                         }
3368                 }
3369                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3370                     $line !~ /for\s*\(.*;\s+\)/ &&
3371                     $line !~ /:\s+\)/) {
3372                         if (ERROR("SPACING",
3373                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3374                             $fix) {
3375                                 $fixed[$linenr - 1] =~
3376                                     s/\s+\)/\)/;
3377                         }
3378                 }
3379
3380 #goto labels aren't indented, allow a single space however
3381                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3382                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3383                         if (WARN("INDENTED_LABEL",
3384                                  "labels should not be indented\n" . $herecurr) &&
3385                             $fix) {
3386                                 $fixed[$linenr - 1] =~
3387                                     s/^(.)\s+/$1/;
3388                         }
3389                 }
3390
3391 # return is not a function
3392                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3393                         my $spacing = $1;
3394                         if ($^V && $^V ge 5.10.0 &&
3395                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3396                                 my $value = $1;
3397                                 $value = deparenthesize($value);
3398                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3399                                         ERROR("RETURN_PARENTHESES",
3400                                               "return is not a function, parentheses are not required\n" . $herecurr);
3401                                 }
3402                         } elsif ($spacing !~ /\s+/) {
3403                                 ERROR("SPACING",
3404                                       "space required before the open parenthesis '('\n" . $herecurr);
3405                         }
3406                 }
3407
3408 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3409                 if ($^V && $^V ge 5.10.0 &&
3410                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
3411                         my $openparens = $1;
3412                         my $count = $openparens =~ tr@\(@\(@;
3413                         my $msg = "";
3414                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3415                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
3416                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
3417                                 WARN("UNNECESSARY_PARENTHESES",
3418                                      "Unnecessary parentheses$msg\n" . $herecurr);
3419                         }
3420                 }
3421
3422 # Return of what appears to be an errno should normally be -'ve
3423                 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3424                         my $name = $1;
3425                         if ($name ne 'EOF' && $name ne 'ERROR') {
3426                                 WARN("USE_NEGATIVE_ERRNO",
3427                                      "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3428                         }
3429                 }
3430
3431 # Need a space before open parenthesis after if, while etc
3432                 if ($line =~ /\b(if|while|for|switch)\(/) {
3433                         if (ERROR("SPACING",
3434                                   "space required before the open parenthesis '('\n" . $herecurr) &&
3435                             $fix) {
3436                                 $fixed[$linenr - 1] =~
3437                                     s/\b(if|while|for|switch)\(/$1 \(/;
3438                         }
3439                 }
3440
3441 # Check for illegal assignment in if conditional -- and check for trailing
3442 # statements after the conditional.
3443                 if ($line =~ /do\s*(?!{)/) {
3444                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3445                                 ctx_statement_block($linenr, $realcnt, 0)
3446                                         if (!defined $stat);
3447                         my ($stat_next) = ctx_statement_block($line_nr_next,
3448                                                 $remain_next, $off_next);
3449                         $stat_next =~ s/\n./\n /g;
3450                         ##print "stat<$stat> stat_next<$stat_next>\n";
3451
3452                         if ($stat_next =~ /^\s*while\b/) {
3453                                 # If the statement carries leading newlines,
3454                                 # then count those as offsets.
3455                                 my ($whitespace) =
3456                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3457                                 my $offset =
3458                                         statement_rawlines($whitespace) - 1;
3459
3460                                 $suppress_whiletrailers{$line_nr_next +
3461                                                                 $offset} = 1;
3462                         }
3463                 }
3464                 if (!defined $suppress_whiletrailers{$linenr} &&
3465                     defined($stat) && defined($cond) &&
3466                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3467                         my ($s, $c) = ($stat, $cond);
3468
3469                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3470                                 ERROR("ASSIGN_IN_IF",
3471                                       "do not use assignment in if condition\n" . $herecurr);
3472                         }
3473
3474                         # Find out what is on the end of the line after the
3475                         # conditional.
3476                         substr($s, 0, length($c), '');
3477                         $s =~ s/\n.*//g;
3478                         $s =~ s/$;//g;  # Remove any comments
3479                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3480                             $c !~ /}\s*while\s*/)
3481                         {
3482                                 # Find out how long the conditional actually is.
3483                                 my @newlines = ($c =~ /\n/gs);
3484                                 my $cond_lines = 1 + $#newlines;
3485                                 my $stat_real = '';
3486
3487                                 $stat_real = raw_line($linenr, $cond_lines)
3488                                                         . "\n" if ($cond_lines);
3489                                 if (defined($stat_real) && $cond_lines > 1) {
3490                                         $stat_real = "[...]\n$stat_real";
3491                                 }
3492
3493                                 ERROR("TRAILING_STATEMENTS",
3494                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
3495                         }
3496                 }
3497
3498 # Check for bitwise tests written as boolean
3499                 if ($line =~ /
3500                         (?:
3501                                 (?:\[|\(|\&\&|\|\|)
3502                                 \s*0[xX][0-9]+\s*
3503                                 (?:\&\&|\|\|)
3504                         |
3505                                 (?:\&\&|\|\|)
3506                                 \s*0[xX][0-9]+\s*
3507                                 (?:\&\&|\|\||\)|\])
3508                         )/x)
3509                 {
3510                         WARN("HEXADECIMAL_BOOLEAN_TEST",
3511                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3512                 }
3513
3514 # if and else should not have general statements after it
3515                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3516                         my $s = $1;
3517                         $s =~ s/$;//g;  # Remove any comments
3518                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3519                                 ERROR("TRAILING_STATEMENTS",
3520                                       "trailing statements should be on next line\n" . $herecurr);
3521                         }
3522                 }
3523 # if should not continue a brace
3524                 if ($line =~ /}\s*if\b/) {
3525                         ERROR("TRAILING_STATEMENTS",
3526                               "trailing statements should be on next line\n" .
3527                                 $herecurr);
3528                 }
3529 # case and default should not have general statements after them
3530                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3531                     $line !~ /\G(?:
3532                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3533                         \s*return\s+
3534                     )/xg)
3535                 {
3536                         ERROR("TRAILING_STATEMENTS",
3537                               "trailing statements should be on next line\n" . $herecurr);
3538                 }
3539
3540                 # Check for }<nl>else {, these must be at the same
3541                 # indent level to be relevant to each other.
3542                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3543                                                 $previndent == $indent) {
3544                         ERROR("ELSE_AFTER_BRACE",
3545                               "else should follow close brace '}'\n" . $hereprev);
3546                 }
3547
3548                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3549                                                 $previndent == $indent) {
3550                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3551
3552                         # Find out what is on the end of the line after the
3553                         # conditional.
3554                         substr($s, 0, length($c), '');
3555                         $s =~ s/\n.*//g;
3556
3557                         if ($s =~ /^\s*;/) {
3558                                 ERROR("WHILE_AFTER_BRACE",
3559                                       "while should follow close brace '}'\n" . $hereprev);
3560                         }
3561                 }
3562
3563 #Specific variable tests
3564                 while ($line =~ m{($Constant|$Lval)}g) {
3565                         my $var = $1;
3566
3567 #gcc binary extension
3568                         if ($var =~ /^$Binary$/) {
3569                                 if (WARN("GCC_BINARY_CONSTANT",
3570                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3571                                     $fix) {
3572                                         my $hexval = sprintf("0x%x", oct($var));
3573                                         $fixed[$linenr - 1] =~
3574                                             s/\b$var\b/$hexval/;
3575                                 }
3576                         }
3577
3578 #CamelCase
3579                         if ($var !~ /^$Constant$/ &&
3580                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3581 #Ignore Page<foo> variants
3582                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3583 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3584                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3585                                 while ($var =~ m{($Ident)}g) {
3586                                         my $word = $1;
3587                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3588                                         if ($check) {
3589                                                 seed_camelcase_includes();
3590                                                 if (!$file && !$camelcase_file_seeded) {
3591                                                         seed_camelcase_file($realfile);
3592                                                         $camelcase_file_seeded = 1;
3593                                                 }
3594                                         }
3595                                         if (!defined $camelcase{$word}) {
3596                                                 $camelcase{$word} = 1;
3597                                                 CHK("CAMELCASE",
3598                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
3599                                         }
3600                                 }
3601                         }
3602                 }
3603
3604 #no spaces allowed after \ in define
3605                 if ($line =~ /\#\s*define.*\\\s+$/) {
3606                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3607                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3608                             $fix) {
3609                                 $fixed[$linenr - 1] =~ s/\s+$//;
3610                         }
3611                 }
3612
3613 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3614                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3615                         my $file = "$1.h";
3616                         my $checkfile = "include/linux/$file";
3617                         if (-f "$root/$checkfile" &&
3618                             $realfile ne $checkfile &&
3619                             $1 !~ /$allowed_asm_includes/)
3620                         {
3621                                 if ($realfile =~ m{^arch/}) {
3622                                         CHK("ARCH_INCLUDE_LINUX",
3623                                             "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3624                                 } else {
3625                                         WARN("INCLUDE_LINUX",
3626                                              "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3627                                 }
3628                         }
3629                 }
3630
3631 # multi-statement macros should be enclosed in a do while loop, grab the
3632 # first statement and ensure its the whole macro if its not enclosed
3633 # in a known good container
3634                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3635                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3636                         my $ln = $linenr;
3637                         my $cnt = $realcnt;
3638                         my ($off, $dstat, $dcond, $rest);
3639                         my $ctx = '';
3640                         ($dstat, $dcond, $ln, $cnt, $off) =
3641                                 ctx_statement_block($linenr, $realcnt, 0);
3642                         $ctx = $dstat;
3643                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3644                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3645
3646                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3647                         $dstat =~ s/$;//g;
3648                         $dstat =~ s/\\\n.//g;
3649                         $dstat =~ s/^\s*//s;
3650                         $dstat =~ s/\s*$//s;
3651
3652                         # Flatten any parentheses and braces
3653                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3654                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
3655                                $dstat =~ s/\[[^\[\]]*\]/1/)
3656                         {
3657                         }
3658
3659                         # Flatten any obvious string concatentation.
3660                         while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3661                                $dstat =~ s/$Ident\s*("X*")/$1/)
3662                         {
3663                         }
3664
3665                         my $exceptions = qr{
3666                                 $Declare|
3667                                 module_param_named|
3668                                 MODULE_PARM_DESC|
3669                                 DECLARE_PER_CPU|
3670                                 DEFINE_PER_CPU|
3671                                 __typeof__\(|
3672                                 union|
3673                                 struct|
3674                                 \.$Ident\s*=\s*|
3675                                 ^\"|\"$
3676                         }x;
3677                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3678                         if ($dstat ne '' &&
3679                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
3680                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
3681                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3682                             $dstat !~ /^'X'$/ &&                                        # character constants
3683                             $dstat !~ /$exceptions/ &&
3684                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
3685                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
3686                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
3687                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
3688                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
3689                             $dstat !~ /^do\s*{/ &&                                      # do {...
3690                             $dstat !~ /^\({/ &&                                         # ({...
3691                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3692                         {
3693                                 $ctx =~ s/\n*$//;
3694                                 my $herectx = $here . "\n";
3695                                 my $cnt = statement_rawlines($ctx);
3696
3697                                 for (my $n = 0; $n < $cnt; $n++) {
3698                                         $herectx .= raw_line($linenr, $n) . "\n";
3699                                 }
3700
3701                                 if ($dstat =~ /;/) {
3702                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3703                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3704                                 } else {
3705                                         ERROR("COMPLEX_MACRO",
3706                                               "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3707                                 }
3708                         }
3709
3710 # check for line continuations outside of #defines, preprocessor #, and asm
3711
3712                 } else {
3713                         if ($prevline !~ /^..*\\$/ &&
3714                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
3715                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
3716                             $line =~ /^\+.*\\$/) {
3717                                 WARN("LINE_CONTINUATIONS",
3718                                      "Avoid unnecessary line continuations\n" . $herecurr);
3719                         }
3720                 }
3721
3722 # do {} while (0) macro tests:
3723 # single-statement macros do not need to be enclosed in do while (0) loop,
3724 # macro should not end with a semicolon
3725                 if ($^V && $^V ge 5.10.0 &&
3726                     $realfile !~ m@/vmlinux.lds.h$@ &&
3727                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3728                         my $ln = $linenr;
3729                         my $cnt = $realcnt;
3730                         my ($off, $dstat, $dcond, $rest);
3731                         my $ctx = '';
3732                         ($dstat, $dcond, $ln, $cnt, $off) =
3733                                 ctx_statement_block($linenr, $realcnt, 0);
3734                         $ctx = $dstat;
3735
3736                         $dstat =~ s/\\\n.//g;
3737
3738                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3739                                 my $stmts = $2;
3740                                 my $semis = $3;
3741
3742                                 $ctx =~ s/\n*$//;
3743                                 my $cnt = statement_rawlines($ctx);
3744                                 my $herectx = $here . "\n";
3745
3746                                 for (my $n = 0; $n < $cnt; $n++) {
3747                                         $herectx .= raw_line($linenr, $n) . "\n";
3748                                 }
3749
3750                                 if (($stmts =~ tr/;/;/) == 1 &&
3751                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
3752                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3753                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3754                                 }
3755                                 if (defined $semis && $semis ne "") {
3756                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3757                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3758                                 }
3759                         }
3760                 }
3761
3762 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3763 # all assignments may have only one of the following with an assignment:
3764 #       .
3765 #       ALIGN(...)
3766 #       VMLINUX_SYMBOL(...)
3767                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3768                         WARN("MISSING_VMLINUX_SYMBOL",
3769                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3770                 }
3771
3772 # check for redundant bracing round if etc
3773                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3774                         my ($level, $endln, @chunks) =
3775                                 ctx_statement_full($linenr, $realcnt, 1);
3776                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3777                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3778                         if ($#chunks > 0 && $level == 0) {
3779                                 my @allowed = ();
3780                                 my $allow = 0;
3781                                 my $seen = 0;
3782                                 my $herectx = $here . "\n";
3783                                 my $ln = $linenr - 1;
3784                                 for my $chunk (@chunks) {
3785                                         my ($cond, $block) = @{$chunk};
3786
3787                                         # If the condition carries leading newlines, then count those as offsets.
3788                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3789                                         my $offset = statement_rawlines($whitespace) - 1;
3790
3791                                         $allowed[$allow] = 0;
3792                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3793
3794                                         # We have looked at and allowed this specific line.
3795                                         $suppress_ifbraces{$ln + $offset} = 1;
3796
3797                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3798                                         $ln += statement_rawlines($block) - 1;
3799
3800                                         substr($block, 0, length($cond), '');
3801
3802                                         $seen++ if ($block =~ /^\s*{/);
3803
3804                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3805                                         if (statement_lines($cond) > 1) {
3806                                                 #print "APW: ALLOWED: cond<$cond>\n";
3807                                                 $allowed[$allow] = 1;
3808                                         }
3809                                         if ($block =~/\b(?:if|for|while)\b/) {
3810                                                 #print "APW: ALLOWED: block<$block>\n";
3811                                                 $allowed[$allow] = 1;
3812                                         }
3813                                         if (statement_block_size($block) > 1) {
3814                                                 #print "APW: ALLOWED: lines block<$block>\n";
3815                                                 $allowed[$allow] = 1;
3816                                         }
3817                                         $allow++;
3818                                 }
3819                                 if ($seen) {
3820                                         my $sum_allowed = 0;
3821                                         foreach (@allowed) {
3822                                                 $sum_allowed += $_;
3823                                         }
3824                                         if ($sum_allowed == 0) {
3825                                                 WARN("BRACES",
3826                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
3827                                         } elsif ($sum_allowed != $allow &&
3828                                                  $seen != $allow) {
3829                                                 CHK("BRACES",
3830                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
3831                                         }
3832                                 }
3833                         }
3834                 }
3835                 if (!defined $suppress_ifbraces{$linenr - 1} &&
3836                                         $line =~ /\b(if|while|for|else)\b/) {
3837                         my $allowed = 0;
3838
3839                         # Check the pre-context.
3840                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3841                                 #print "APW: ALLOWED: pre<$1>\n";
3842                                 $allowed = 1;
3843                         }
3844
3845                         my ($level, $endln, @chunks) =
3846                                 ctx_statement_full($linenr, $realcnt, $-[0]);
3847
3848                         # Check the condition.
3849                         my ($cond, $block) = @{$chunks[0]};
3850                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3851                         if (defined $cond) {
3852                                 substr($block, 0, length($cond), '');
3853                         }
3854                         if (statement_lines($cond) > 1) {
3855                                 #print "APW: ALLOWED: cond<$cond>\n";
3856                                 $allowed = 1;
3857                         }
3858                         if ($block =~/\b(?:if|for|while)\b/) {
3859                                 #print "APW: ALLOWED: block<$block>\n";
3860                                 $allowed = 1;
3861                         }
3862                         if (statement_block_size($block) > 1) {
3863                                 #print "APW: ALLOWED: lines block<$block>\n";
3864                                 $allowed = 1;
3865                         }
3866                         # Check the post-context.
3867                         if (defined $chunks[1]) {
3868                                 my ($cond, $block) = @{$chunks[1]};
3869                                 if (defined $cond) {
3870                                         substr($block, 0, length($cond), '');
3871                                 }
3872                                 if ($block =~ /^\s*\{/) {
3873                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
3874                                         $allowed = 1;
3875                                 }
3876                         }
3877                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3878                                 my $herectx = $here . "\n";
3879                                 my $cnt = statement_rawlines($block);
3880
3881                                 for (my $n = 0; $n < $cnt; $n++) {
3882                                         $herectx .= raw_line($linenr, $n) . "\n";
3883                                 }
3884
3885                                 WARN("BRACES",
3886                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
3887                         }
3888                 }
3889
3890 # check for unnecessary blank lines around braces
3891                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
3892                         CHK("BRACES",
3893                             "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3894                 }
3895                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
3896                         CHK("BRACES",
3897                             "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3898                 }
3899
3900 # no volatiles please
3901                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3902                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3903                         WARN("VOLATILE",
3904                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3905                 }
3906
3907 # warn about #if 0
3908                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3909                         CHK("REDUNDANT_CODE",
3910                             "if this code is redundant consider removing it\n" .
3911                                 $herecurr);
3912                 }
3913
3914 # check for needless "if (<foo>) fn(<foo>)" uses
3915                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
3916                         my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
3917                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
3918                                 WARN('NEEDLESS_IF',
3919                                      "$1(NULL) is safe this check is probably not required\n" . $hereprev);
3920                         }
3921                 }
3922
3923 # check for bad placement of section $InitAttribute (e.g.: __initdata)
3924                 if ($line =~ /(\b$InitAttribute\b)/) {
3925                         my $attr = $1;
3926                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
3927                                 my $ptr = $1;
3928                                 my $var = $2;
3929                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
3930                                       ERROR("MISPLACED_INIT",
3931                                             "$attr should be placed after $var\n" . $herecurr)) ||
3932                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
3933                                       WARN("MISPLACED_INIT",
3934                                            "$attr should be placed after $var\n" . $herecurr))) &&
3935                                     $fix) {
3936                                         $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;
3937                                 }
3938                         }
3939                 }
3940
3941 # check for $InitAttributeData (ie: __initdata) with const
3942                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
3943                         my $attr = $1;
3944                         $attr =~ /($InitAttributePrefix)(.*)/;
3945                         my $attr_prefix = $1;
3946                         my $attr_type = $2;
3947                         if (ERROR("INIT_ATTRIBUTE",
3948                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
3949                             $fix) {
3950                                 $fixed[$linenr - 1] =~
3951                                     s/$InitAttributeData/${attr_prefix}initconst/;
3952                         }
3953                 }
3954
3955 # check for $InitAttributeConst (ie: __initconst) without const
3956                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
3957                         my $attr = $1;
3958                         if (ERROR("INIT_ATTRIBUTE",
3959                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
3960                             $fix) {
3961                                 my $lead = $fixed[$linenr - 1] =~
3962                                     /(^\+\s*(?:static\s+))/;
3963                                 $lead = rtrim($1);
3964                                 $lead = "$lead " if ($lead !~ /^\+$/);
3965                                 $lead = "${lead}const ";
3966                                 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
3967                         }
3968                 }
3969
3970 # don't use __constant_<foo> functions outside of include/uapi/
3971                 if ($realfile !~ m@^include/uapi/@ &&
3972                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
3973                         my $constant_func = $1;
3974                         my $func = $constant_func;
3975                         $func =~ s/^__constant_//;
3976                         if (WARN("CONSTANT_CONVERSION",
3977                                  "$constant_func should be $func\n" . $herecurr) &&
3978                             $fix) {
3979                                 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
3980                         }
3981                 }
3982
3983 # prefer usleep_range over udelay
3984                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
3985                         my $delay = $1;
3986                         # ignore udelay's < 10, however
3987                         if (! ($delay < 10) ) {
3988                                 CHK("USLEEP_RANGE",
3989                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
3990                         }
3991                         if ($delay > 2000) {
3992                                 WARN("LONG_UDELAY",
3993                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
3994                         }
3995                 }
3996
3997 # warn about unexpectedly long msleep's
3998                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3999                         if ($1 < 20) {
4000                                 WARN("MSLEEP",
4001                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4002                         }
4003                 }
4004
4005 # check for comparisons of jiffies
4006                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4007                         WARN("JIFFIES_COMPARISON",
4008                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4009                 }
4010
4011 # check for comparisons of get_jiffies_64()
4012                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4013                         WARN("JIFFIES_COMPARISON",
4014                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4015                 }
4016
4017 # warn about #ifdefs in C files
4018 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4019 #                       print "#ifdef in C files should be avoided\n";
4020 #                       print "$herecurr";
4021 #                       $clean = 0;
4022 #               }
4023
4024 # warn about spacing in #ifdefs
4025                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4026                         if (ERROR("SPACING",
4027                                   "exactly one space required after that #$1\n" . $herecurr) &&
4028                             $fix) {
4029                                 $fixed[$linenr - 1] =~
4030                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4031                         }
4032
4033                 }
4034
4035 # check for spinlock_t definitions without a comment.
4036                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4037                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4038                         my $which = $1;
4039                         if (!ctx_has_comment($first_line, $linenr)) {
4040                                 CHK("UNCOMMENTED_DEFINITION",
4041                                     "$1 definition without comment\n" . $herecurr);
4042                         }
4043                 }
4044 # check for memory barriers without a comment.
4045                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4046                         if (!ctx_has_comment($first_line, $linenr)) {
4047                                 WARN("MEMORY_BARRIER",
4048                                      "memory barrier without comment\n" . $herecurr);
4049                         }
4050                 }
4051 # check of hardware specific defines
4052                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4053                         CHK("ARCH_DEFINES",
4054                             "architecture specific defines should be avoided\n" .  $herecurr);
4055                 }
4056
4057 # Check that the storage class is at the beginning of a declaration
4058                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4059                         WARN("STORAGE_CLASS",
4060                              "storage class should be at the beginning of the declaration\n" . $herecurr)
4061                 }
4062
4063 # check the location of the inline attribute, that it is between
4064 # storage class and type.
4065                 if ($line =~ /\b$Type\s+$Inline\b/ ||
4066                     $line =~ /\b$Inline\s+$Storage\b/) {
4067                         ERROR("INLINE_LOCATION",
4068                               "inline keyword should sit between storage class and type\n" . $herecurr);
4069                 }
4070
4071 # Check for __inline__ and __inline, prefer inline
4072                 if ($realfile !~ m@\binclude/uapi/@ &&
4073                     $line =~ /\b(__inline__|__inline)\b/) {
4074                         if (WARN("INLINE",
4075                                  "plain inline is preferred over $1\n" . $herecurr) &&
4076                             $fix) {
4077                                 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4078
4079                         }
4080                 }
4081
4082 # Check for __attribute__ packed, prefer __packed
4083                 if ($realfile !~ m@\binclude/uapi/@ &&
4084                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4085                         WARN("PREFER_PACKED",
4086                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4087                 }
4088
4089 # Check for __attribute__ aligned, prefer __aligned
4090                 if ($realfile !~ m@\binclude/uapi/@ &&
4091                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4092                         WARN("PREFER_ALIGNED",
4093                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4094                 }
4095
4096 # Check for __attribute__ format(printf, prefer __printf
4097                 if ($realfile !~ m@\binclude/uapi/@ &&
4098                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4099                         if (WARN("PREFER_PRINTF",
4100                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4101                             $fix) {
4102                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4103
4104                         }
4105                 }
4106
4107 # Check for __attribute__ format(scanf, prefer __scanf
4108                 if ($realfile !~ m@\binclude/uapi/@ &&
4109                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4110                         if (WARN("PREFER_SCANF",
4111                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4112                             $fix) {
4113                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4114                         }
4115                 }
4116
4117 # check for sizeof(&)
4118                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4119                         WARN("SIZEOF_ADDRESS",
4120                              "sizeof(& should be avoided\n" . $herecurr);
4121                 }
4122
4123 # check for sizeof without parenthesis
4124                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4125                         if (WARN("SIZEOF_PARENTHESIS",
4126                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4127                             $fix) {
4128                                 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4129                         }
4130                 }
4131
4132 # check for line continuations in quoted strings with odd counts of "
4133                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4134                         WARN("LINE_CONTINUATIONS",
4135                              "Avoid line continuations in quoted strings\n" . $herecurr);
4136                 }
4137
4138 # check for struct spinlock declarations
4139                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4140                         WARN("USE_SPINLOCK_T",
4141                              "struct spinlock should be spinlock_t\n" . $herecurr);
4142                 }
4143
4144 # check for seq_printf uses that could be seq_puts
4145                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4146                         my $fmt = get_quoted_string($line, $rawline);
4147                         if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4148                                 if (WARN("PREFER_SEQ_PUTS",
4149                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4150                                     $fix) {
4151                                         $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4152                                 }
4153                         }
4154                 }
4155
4156 # Check for misused memsets
4157                 if ($^V && $^V ge 5.10.0 &&
4158                     defined $stat &&
4159                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4160
4161                         my $ms_addr = $2;
4162                         my $ms_val = $7;
4163                         my $ms_size = $12;
4164
4165                         if ($ms_size =~ /^(0x|)0$/i) {
4166                                 ERROR("MEMSET",
4167                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4168                         } elsif ($ms_size =~ /^(0x|)1$/i) {
4169                                 WARN("MEMSET",
4170                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4171                         }
4172                 }
4173
4174 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4175                 if ($^V && $^V ge 5.10.0 &&
4176                     $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4177                         if (WARN("PREFER_ETHER_ADDR_COPY",
4178                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4179                             $fix) {
4180                                 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4181                         }
4182                 }
4183
4184 # typecasts on min/max could be min_t/max_t
4185                 if ($^V && $^V ge 5.10.0 &&
4186                     defined $stat &&
4187                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4188                         if (defined $2 || defined $7) {
4189                                 my $call = $1;
4190                                 my $cast1 = deparenthesize($2);
4191                                 my $arg1 = $3;
4192                                 my $cast2 = deparenthesize($7);
4193                                 my $arg2 = $8;
4194                                 my $cast;
4195
4196                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4197                                         $cast = "$cast1 or $cast2";
4198                                 } elsif ($cast1 ne "") {
4199                                         $cast = $cast1;
4200                                 } else {
4201                                         $cast = $cast2;
4202                                 }
4203                                 WARN("MINMAX",
4204                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4205                         }
4206                 }
4207
4208 # check usleep_range arguments
4209                 if ($^V && $^V ge 5.10.0 &&
4210                     defined $stat &&
4211                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4212                         my $min = $1;
4213                         my $max = $7;
4214                         if ($min eq $max) {
4215                                 WARN("USLEEP_RANGE",
4216                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4217                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4218                                  $min > $max) {
4219                                 WARN("USLEEP_RANGE",
4220                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4221                         }
4222                 }
4223
4224 # check for naked sscanf
4225                 if ($^V && $^V ge 5.10.0 &&
4226                     defined $stat &&
4227                     $line =~ /\bsscanf\b/ &&
4228                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4229                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4230                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4231                         my $lc = $stat =~ tr@\n@@;
4232                         $lc = $lc + $linenr;
4233                         my $stat_real = raw_line($linenr, 0);
4234                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
4235                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4236                         }
4237                         WARN("NAKED_SSCANF",
4238                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4239                 }
4240
4241 # check for new externs in .h files.
4242                 if ($realfile =~ /\.h$/ &&
4243                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4244                         if (CHK("AVOID_EXTERNS",
4245                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4246                             $fix) {
4247                                 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4248                         }
4249                 }
4250
4251 # check for new externs in .c files.
4252                 if ($realfile =~ /\.c$/ && defined $stat &&
4253                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4254                 {
4255                         my $function_name = $1;
4256                         my $paren_space = $2;
4257
4258                         my $s = $stat;
4259                         if (defined $cond) {
4260                                 substr($s, 0, length($cond), '');
4261                         }
4262                         if ($s =~ /^\s*;/ &&
4263                             $function_name ne 'uninitialized_var')
4264                         {
4265                                 WARN("AVOID_EXTERNS",
4266                                      "externs should be avoided in .c files\n" .  $herecurr);
4267                         }
4268
4269                         if ($paren_space =~ /\n/) {
4270                                 WARN("FUNCTION_ARGUMENTS",
4271                                      "arguments for function declarations should follow identifier\n" . $herecurr);
4272                         }
4273
4274                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4275                     $stat =~ /^.\s*extern\s+/)
4276                 {
4277                         WARN("AVOID_EXTERNS",
4278                              "externs should be avoided in .c files\n" .  $herecurr);
4279                 }
4280
4281 # checks for new __setup's
4282                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4283                         my $name = $1;
4284
4285                         if (!grep(/$name/, @setup_docs)) {
4286                                 CHK("UNDOCUMENTED_SETUP",
4287                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4288                         }
4289                 }
4290
4291 # check for pointless casting of kmalloc return
4292                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4293                         WARN("UNNECESSARY_CASTS",
4294                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4295                 }
4296
4297 # alloc style
4298 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4299                 if ($^V && $^V ge 5.10.0 &&
4300                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4301                         CHK("ALLOC_SIZEOF_STRUCT",
4302                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4303                 }
4304
4305 # check for krealloc arg reuse
4306                 if ($^V && $^V ge 5.10.0 &&
4307                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4308                         WARN("KREALLOC_ARG_REUSE",
4309                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4310                 }
4311
4312 # check for alloc argument mismatch
4313                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4314                         WARN("ALLOC_ARRAY_ARGS",
4315                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4316                 }
4317
4318 # check for GFP_NOWAIT use
4319                 if ($line =~ /\b__GFP_NOFAIL\b/) {
4320                         WARN("__GFP_NOFAIL",
4321                              "Use of __GFP_NOFAIL is deprecated, no new users should be added\n" . $herecurr);
4322                 }
4323
4324 # check for multiple semicolons
4325                 if ($line =~ /;\s*;\s*$/) {
4326                         if (WARN("ONE_SEMICOLON",
4327                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
4328                             $fix) {
4329                                 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4330                         }
4331                 }
4332
4333 # check for case / default statements not preceeded by break/fallthrough/switch
4334                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4335                         my $has_break = 0;
4336                         my $has_statement = 0;
4337                         my $count = 0;
4338                         my $prevline = $linenr;
4339                         while ($prevline > 1 && $count < 3 && !$has_break) {
4340                                 $prevline--;
4341                                 my $rline = $rawlines[$prevline - 1];
4342                                 my $fline = $lines[$prevline - 1];
4343                                 last if ($fline =~ /^\@\@/);
4344                                 next if ($fline =~ /^\-/);
4345                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4346                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4347                                 next if ($fline =~ /^.[\s$;]*$/);
4348                                 $has_statement = 1;
4349                                 $count++;
4350                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4351                         }
4352                         if (!$has_break && $has_statement) {
4353                                 WARN("MISSING_BREAK",
4354                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4355                         }
4356                 }
4357
4358 # check for switch/default statements without a break;
4359                 if ($^V && $^V ge 5.10.0 &&
4360                     defined $stat &&
4361                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4362                         my $ctx = '';
4363                         my $herectx = $here . "\n";
4364                         my $cnt = statement_rawlines($stat);
4365                         for (my $n = 0; $n < $cnt; $n++) {
4366                                 $herectx .= raw_line($linenr, $n) . "\n";
4367                         }
4368                         WARN("DEFAULT_NO_BREAK",
4369                              "switch default: should use break\n" . $herectx);
4370                 }
4371
4372 # check for gcc specific __FUNCTION__
4373                 if ($line =~ /\b__FUNCTION__\b/) {
4374                         if (WARN("USE_FUNC",
4375                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
4376                             $fix) {
4377                                 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4378                         }
4379                 }
4380
4381 # check for use of yield()
4382                 if ($line =~ /\byield\s*\(\s*\)/) {
4383                         WARN("YIELD",
4384                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
4385                 }
4386
4387 # check for comparisons against true and false
4388                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4389                         my $lead = $1;
4390                         my $arg = $2;
4391                         my $test = $3;
4392                         my $otype = $4;
4393                         my $trail = $5;
4394                         my $op = "!";
4395
4396                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4397
4398                         my $type = lc($otype);
4399                         if ($type =~ /^(?:true|false)$/) {
4400                                 if (("$test" eq "==" && "$type" eq "true") ||
4401                                     ("$test" eq "!=" && "$type" eq "false")) {
4402                                         $op = "";
4403                                 }
4404
4405                                 CHK("BOOL_COMPARISON",
4406                                     "Using comparison to $otype is error prone\n" . $herecurr);
4407
4408 ## maybe suggesting a correct construct would better
4409 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4410
4411                         }
4412                 }
4413
4414 # check for semaphores initialized locked
4415                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4416                         WARN("CONSIDER_COMPLETION",
4417                              "consider using a completion\n" . $herecurr);
4418                 }
4419
4420 # recommend kstrto* over simple_strto* and strict_strto*
4421                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4422                         WARN("CONSIDER_KSTRTO",
4423                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
4424                 }
4425
4426 # check for __initcall(), use device_initcall() explicitly please
4427                 if ($line =~ /^.\s*__initcall\s*\(/) {
4428                         WARN("USE_DEVICE_INITCALL",
4429                              "please use device_initcall() instead of __initcall()\n" . $herecurr);
4430                 }
4431
4432 # check for various ops structs, ensure they are const.
4433                 my $struct_ops = qr{acpi_dock_ops|
4434                                 address_space_operations|
4435                                 backlight_ops|
4436                                 block_device_operations|
4437                                 dentry_operations|
4438                                 dev_pm_ops|
4439                                 dma_map_ops|
4440                                 extent_io_ops|
4441                                 file_lock_operations|
4442                                 file_operations|
4443                                 hv_ops|
4444                                 ide_dma_ops|
4445                                 intel_dvo_dev_ops|
4446                                 item_operations|
4447                                 iwl_ops|
4448                                 kgdb_arch|
4449                                 kgdb_io|
4450                                 kset_uevent_ops|
4451                                 lock_manager_operations|
4452                                 microcode_ops|
4453                                 mtrr_ops|
4454                                 neigh_ops|
4455                                 nlmsvc_binding|
4456                                 pci_raw_ops|
4457                                 pipe_buf_operations|
4458                                 platform_hibernation_ops|
4459                                 platform_suspend_ops|
4460                                 proto_ops|
4461                                 rpc_pipe_ops|
4462                                 seq_operations|
4463                                 snd_ac97_build_ops|
4464                                 soc_pcmcia_socket_ops|
4465                                 stacktrace_ops|
4466                                 sysfs_ops|
4467                                 tty_operations|
4468                                 usb_mon_operations|
4469                                 wd_ops}x;
4470                 if ($line !~ /\bconst\b/ &&
4471                     $line =~ /\bstruct\s+($struct_ops)\b/) {
4472                         WARN("CONST_STRUCT",
4473                              "struct $1 should normally be const\n" .
4474                                 $herecurr);
4475                 }
4476
4477 # use of NR_CPUS is usually wrong
4478 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4479                 if ($line =~ /\bNR_CPUS\b/ &&
4480                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4481                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4482                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4483                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4484                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4485                 {
4486                         WARN("NR_CPUS",
4487                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4488                 }
4489
4490 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4491                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4492                         ERROR("DEFINE_ARCH_HAS",
4493                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4494                 }
4495
4496 # check for %L{u,d,i} in strings
4497                 my $string;
4498                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4499                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4500                         $string =~ s/%%/__/g;
4501                         if ($string =~ /(?<!%)%L[udi]/) {
4502                                 WARN("PRINTF_L",
4503                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4504                                 last;
4505                         }
4506                 }
4507
4508 # whine mightly about in_atomic
4509                 if ($line =~ /\bin_atomic\s*\(/) {
4510                         if ($realfile =~ m@^drivers/@) {
4511                                 ERROR("IN_ATOMIC",
4512                                       "do not use in_atomic in drivers\n" . $herecurr);
4513                         } elsif ($realfile !~ m@^kernel/@) {
4514                                 WARN("IN_ATOMIC",
4515                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4516                         }
4517                 }
4518
4519 # check for lockdep_set_novalidate_class
4520                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4521                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
4522                         if ($realfile !~ m@^kernel/lockdep@ &&
4523                             $realfile !~ m@^include/linux/lockdep@ &&
4524                             $realfile !~ m@^drivers/base/core@) {
4525                                 ERROR("LOCKDEP",
4526                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4527                         }
4528                 }
4529
4530                 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4531                     $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4532                         WARN("EXPORTED_WORLD_WRITABLE",
4533                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4534                 }
4535
4536 # Mode permission misuses where it seems decimal should be octal
4537 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
4538                 if ($^V && $^V ge 5.10.0 &&
4539                     $line =~ /$mode_perms_search/) {
4540                         foreach my $entry (@mode_permission_funcs) {
4541                                 my $func = $entry->[0];
4542                                 my $arg_pos = $entry->[1];
4543
4544                                 my $skip_args = "";
4545                                 if ($arg_pos > 1) {
4546                                         $arg_pos--;
4547                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4548                                 }
4549                                 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4550                                 if ($line =~ /$test/) {
4551                                         my $val = $1;
4552                                         $val = $6 if ($skip_args ne "");
4553
4554                                         if ($val !~ /^0$/ &&
4555                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4556                                              length($val) ne 4)) {
4557                                                 ERROR("NON_OCTAL_PERMISSIONS",
4558                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4559                                         }
4560                                 }
4561                         }
4562                 }
4563         }
4564
4565         # If we have no input at all, then there is nothing to report on
4566         # so just keep quiet.
4567         if ($#rawlines == -1) {
4568                 exit(0);
4569         }
4570
4571         # In mailback mode only produce a report in the negative, for
4572         # things that appear to be patches.
4573         if ($mailback && ($clean == 1 || !$is_patch)) {
4574                 exit(0);
4575         }
4576
4577         # This is not a patch, and we are are in 'no-patch' mode so
4578         # just keep quiet.
4579         if (!$chk_patch && !$is_patch) {
4580                 exit(0);
4581         }
4582
4583         if (!$is_patch) {
4584                 ERROR("NOT_UNIFIED_DIFF",
4585                       "Does not appear to be a unified-diff format patch\n");
4586         }
4587         if ($is_patch && $chk_signoff && $signoff == 0) {
4588                 ERROR("MISSING_SIGN_OFF",
4589                       "Missing Signed-off-by: line(s)\n");
4590         }
4591
4592         print report_dump();
4593         if ($summary && !($clean == 1 && $quiet == 1)) {
4594                 print "$filename " if ($summary_file);
4595                 print "total: $cnt_error errors, $cnt_warn warnings, " .
4596                         (($check)? "$cnt_chk checks, " : "") .
4597                         "$cnt_lines lines checked\n";
4598                 print "\n" if ($quiet == 0);
4599         }
4600
4601         if ($quiet == 0) {
4602
4603                 if ($^V lt 5.10.0) {
4604                         print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4605                         print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4606                 }
4607
4608                 # If there were whitespace errors which cleanpatch can fix
4609                 # then suggest that.
4610                 if ($rpt_cleaners) {
4611                         print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4612                         print "      scripts/cleanfile\n\n";
4613                         $rpt_cleaners = 0;
4614                 }
4615         }
4616
4617         hash_show_words(\%use_type, "Used");
4618         hash_show_words(\%ignore_type, "Ignored");
4619
4620         if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4621                 my $newfile = $filename;
4622                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4623                 my $linecount = 0;
4624                 my $f;
4625
4626                 open($f, '>', $newfile)
4627                     or die "$P: Can't open $newfile for write\n";
4628                 foreach my $fixed_line (@fixed) {
4629                         $linecount++;
4630                         if ($file) {
4631                                 if ($linecount > 3) {
4632                                         $fixed_line =~ s/^\+//;
4633                                         print $f $fixed_line. "\n";
4634                                 }
4635                         } else {
4636                                 print $f $fixed_line . "\n";
4637                         }
4638                 }
4639                 close($f);
4640
4641                 if (!$quiet) {
4642                         print << "EOM";
4643 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4644
4645 Do _NOT_ trust the results written to this file.
4646 Do _NOT_ submit these changes without inspecting them for correctness.
4647
4648 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4649 No warranties, expressed or implied...
4650
4651 EOM
4652                 }
4653         }
4654
4655         if ($clean == 1 && $quiet == 0) {
4656                 print "$vname has no obvious style problems and is ready for submission.\n"
4657         }
4658         if ($clean == 0 && $quiet == 0) {
4659                 print << "EOM";
4660 $vname has style problems, please review.
4661
4662 If any of these errors are false positives, please report
4663 them to the maintainer, see CHECKPATCH in MAINTAINERS.
4664 EOM
4665         }
4666
4667         return $clean;
4668 }