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