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