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