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