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