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