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 # Block comment * alignment
2983                 if ($prevline =~ /$;[ \t]*$/ &&                 #ends in comment
2984                     (($prevrawline =~ /^\+.*?\/\*/ &&           #starting /*
2985                       $prevrawline !~ /\*\/[ \t]*$/) ||         #no trailing */
2986                      $prevrawline =~ /^\+[ \t]*\*/) &&          #starting *
2987                     $rawline =~ /^\+[ \t]*\*/) {                #rawline *
2988                         $prevrawline =~ m@^\+([ \t]*/?)\*@;
2989                         my $oldindent = expand_tabs($1);
2990                         $rawline =~ m@^\+([ \t]*)\*@;
2991                         my $newindent = $1;
2992                         my $test_comment = '^\\+' . "$;" x (length($newindent) + 1);
2993                         $newindent = expand_tabs($newindent);
2994                         if ($line =~ /$test_comment/ &&
2995                             length($oldindent) ne length($newindent)) {
2996                                 WARN("BLOCK_COMMENT_STYLE",
2997                                      "Block comments should align the * on each line\n" . $hereprev);
2998                         }
2999                 }
3000
3001 # check for missing blank lines after struct/union declarations
3002 # with exceptions for various attributes and macros
3003                 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3004                     $line =~ /^\+/ &&
3005                     !($line =~ /^\+\s*$/ ||
3006                       $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3007                       $line =~ /^\+\s*MODULE_/i ||
3008                       $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3009                       $line =~ /^\+[a-z_]*init/ ||
3010                       $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3011                       $line =~ /^\+\s*DECLARE/ ||
3012                       $line =~ /^\+\s*__setup/)) {
3013                         if (CHK("LINE_SPACING",
3014                                 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3015                             $fix) {
3016                                 fix_insert_line($fixlinenr, "\+");
3017                         }
3018                 }
3019
3020 # check for multiple consecutive blank lines
3021                 if ($prevline =~ /^[\+ ]\s*$/ &&
3022                     $line =~ /^\+\s*$/ &&
3023                     $last_blank_line != ($linenr - 1)) {
3024                         if (CHK("LINE_SPACING",
3025                                 "Please don't use multiple blank lines\n" . $hereprev) &&
3026                             $fix) {
3027                                 fix_delete_line($fixlinenr, $rawline);
3028                         }
3029
3030                         $last_blank_line = $linenr;
3031                 }
3032
3033 # check for missing blank lines after declarations
3034                 if ($sline =~ /^\+\s+\S/ &&                     #Not at char 1
3035                         # actual declarations
3036                     ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3037                         # function pointer declarations
3038                      $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3039                         # foo bar; where foo is some local typedef or #define
3040                      $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3041                         # known declaration macros
3042                      $prevline =~ /^\+\s+$declaration_macros/) &&
3043                         # for "else if" which can look like "$Ident $Ident"
3044                     !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3045                         # other possible extensions of declaration lines
3046                       $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3047                         # not starting a section or a macro "\" extended line
3048                       $prevline =~ /(?:\{\s*|\\)$/) &&
3049                         # looks like a declaration
3050                     !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3051                         # function pointer declarations
3052                       $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3053                         # foo bar; where foo is some local typedef or #define
3054                       $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3055                         # known declaration macros
3056                       $sline =~ /^\+\s+$declaration_macros/ ||
3057                         # start of struct or union or enum
3058                       $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3059                         # start or end of block or continuation of declaration
3060                       $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3061                         # bitfield continuation
3062                       $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3063                         # other possible extensions of declaration lines
3064                       $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3065                         # indentation of previous and current line are the same
3066                     (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3067                         if (WARN("LINE_SPACING",
3068                                  "Missing a blank line after declarations\n" . $hereprev) &&
3069                             $fix) {
3070                                 fix_insert_line($fixlinenr, "\+");
3071                         }
3072                 }
3073
3074 # check for spaces at the beginning of a line.
3075 # Exceptions:
3076 #  1) within comments
3077 #  2) indented preprocessor commands
3078 #  3) hanging labels
3079                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
3080                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3081                         if (WARN("LEADING_SPACE",
3082                                  "please, no spaces at the start of a line\n" . $herevet) &&
3083                             $fix) {
3084                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3085                         }
3086                 }
3087
3088 # check we are in a valid C source file if not then ignore this hunk
3089                 next if ($realfile !~ /\.(h|c)$/);
3090
3091 # check indentation of any line with a bare else
3092 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3093 # if the previous line is a break or return and is indented 1 tab more...
3094                 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3095                         my $tabs = length($1) + 1;
3096                         if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3097                             ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3098                              defined $lines[$linenr] &&
3099                              $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3100                                 WARN("UNNECESSARY_ELSE",
3101                                      "else is not generally useful after a break or return\n" . $hereprev);
3102                         }
3103                 }
3104
3105 # check indentation of a line with a break;
3106 # if the previous line is a goto or return and is indented the same # of tabs
3107                 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3108                         my $tabs = $1;
3109                         if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3110                                 WARN("UNNECESSARY_BREAK",
3111                                      "break is not useful after a goto or return\n" . $hereprev);
3112                         }
3113                 }
3114
3115 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
3116                 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
3117                         WARN("CONFIG_EXPERIMENTAL",
3118                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
3119                 }
3120
3121 # check for RCS/CVS revision markers
3122                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3123                         WARN("CVS_KEYWORD",
3124                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3125                 }
3126
3127 # Blackfin: don't use __builtin_bfin_[cs]sync
3128                 if ($line =~ /__builtin_bfin_csync/) {
3129                         my $herevet = "$here\n" . cat_vet($line) . "\n";
3130                         ERROR("CSYNC",
3131                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3132                 }
3133                 if ($line =~ /__builtin_bfin_ssync/) {
3134                         my $herevet = "$here\n" . cat_vet($line) . "\n";
3135                         ERROR("SSYNC",
3136                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3137                 }
3138
3139 # check for old HOTPLUG __dev<foo> section markings
3140                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3141                         WARN("HOTPLUG_SECTION",
3142                              "Using $1 is unnecessary\n" . $herecurr);
3143                 }
3144
3145 # Check for potential 'bare' types
3146                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3147                     $realline_next);
3148 #print "LINE<$line>\n";
3149                 if ($linenr >= $suppress_statement &&
3150                     $realcnt && $sline =~ /.\s*\S/) {
3151                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3152                                 ctx_statement_block($linenr, $realcnt, 0);
3153                         $stat =~ s/\n./\n /g;
3154                         $cond =~ s/\n./\n /g;
3155
3156 #print "linenr<$linenr> <$stat>\n";
3157                         # If this statement has no statement boundaries within
3158                         # it there is no point in retrying a statement scan
3159                         # until we hit end of it.
3160                         my $frag = $stat; $frag =~ s/;+\s*$//;
3161                         if ($frag !~ /(?:{|;)/) {
3162 #print "skip<$line_nr_next>\n";
3163                                 $suppress_statement = $line_nr_next;
3164                         }
3165
3166                         # Find the real next line.
3167                         $realline_next = $line_nr_next;
3168                         if (defined $realline_next &&
3169                             (!defined $lines[$realline_next - 1] ||
3170                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3171                                 $realline_next++;
3172                         }
3173
3174                         my $s = $stat;
3175                         $s =~ s/{.*$//s;
3176
3177                         # Ignore goto labels.
3178                         if ($s =~ /$Ident:\*$/s) {
3179
3180                         # Ignore functions being called
3181                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3182
3183                         } elsif ($s =~ /^.\s*else\b/s) {
3184
3185                         # declarations always start with types
3186                         } 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) {
3187                                 my $type = $1;
3188                                 $type =~ s/\s+/ /g;
3189                                 possible($type, "A:" . $s);
3190
3191                         # definitions in global scope can only start with types
3192                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3193                                 possible($1, "B:" . $s);
3194                         }
3195
3196                         # any (foo ... *) is a pointer cast, and foo is a type
3197                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3198                                 possible($1, "C:" . $s);
3199                         }
3200
3201                         # Check for any sort of function declaration.
3202                         # int foo(something bar, other baz);
3203                         # void (*store_gdt)(x86_descr_ptr *);
3204                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3205                                 my ($name_len) = length($1);
3206
3207                                 my $ctx = $s;
3208                                 substr($ctx, 0, $name_len + 1, '');
3209                                 $ctx =~ s/\)[^\)]*$//;
3210
3211                                 for my $arg (split(/\s*,\s*/, $ctx)) {
3212                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3213
3214                                                 possible($1, "D:" . $s);
3215                                         }
3216                                 }
3217                         }
3218
3219                 }
3220
3221 #
3222 # Checks which may be anchored in the context.
3223 #
3224
3225 # Check for switch () and associated case and default
3226 # statements should be at the same indent.
3227                 if ($line=~/\bswitch\s*\(.*\)/) {
3228                         my $err = '';
3229                         my $sep = '';
3230                         my @ctx = ctx_block_outer($linenr, $realcnt);
3231                         shift(@ctx);
3232                         for my $ctx (@ctx) {
3233                                 my ($clen, $cindent) = line_stats($ctx);
3234                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3235                                                         $indent != $cindent) {
3236                                         $err .= "$sep$ctx\n";
3237                                         $sep = '';
3238                                 } else {
3239                                         $sep = "[...]\n";
3240                                 }
3241                         }
3242                         if ($err ne '') {
3243                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
3244                                       "switch and case should be at the same indent\n$hereline$err");
3245                         }
3246                 }
3247
3248 # if/while/etc brace do not go on next line, unless defining a do while loop,
3249 # or if that brace on the next line is for something else
3250                 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3251                         my $pre_ctx = "$1$2";
3252
3253                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3254
3255                         if ($line =~ /^\+\t{6,}/) {
3256                                 WARN("DEEP_INDENTATION",
3257                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
3258                         }
3259
3260                         my $ctx_cnt = $realcnt - $#ctx - 1;
3261                         my $ctx = join("\n", @ctx);
3262
3263                         my $ctx_ln = $linenr;
3264                         my $ctx_skip = $realcnt;
3265
3266                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3267                                         defined $lines[$ctx_ln - 1] &&
3268                                         $lines[$ctx_ln - 1] =~ /^-/)) {
3269                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3270                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3271                                 $ctx_ln++;
3272                         }
3273
3274                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3275                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3276
3277                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3278                                 ERROR("OPEN_BRACE",
3279                                       "that open brace { should be on the previous line\n" .
3280                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3281                         }
3282                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3283                             $ctx =~ /\)\s*\;\s*$/ &&
3284                             defined $lines[$ctx_ln - 1])
3285                         {
3286                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3287                                 if ($nindent > $indent) {
3288                                         WARN("TRAILING_SEMICOLON",
3289                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
3290                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3291                                 }
3292                         }
3293                 }
3294
3295 # Check relative indent for conditionals and blocks.
3296                 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3297                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3298                                 ctx_statement_block($linenr, $realcnt, 0)
3299                                         if (!defined $stat);
3300                         my ($s, $c) = ($stat, $cond);
3301
3302                         substr($s, 0, length($c), '');
3303
3304                         # remove inline comments
3305                         $s =~ s/$;/ /g;
3306                         $c =~ s/$;/ /g;
3307
3308                         # Find out how long the conditional actually is.
3309                         my @newlines = ($c =~ /\n/gs);
3310                         my $cond_lines = 1 + $#newlines;
3311
3312                         # Make sure we remove the line prefixes as we have
3313                         # none on the first line, and are going to readd them
3314                         # where necessary.
3315                         $s =~ s/\n./\n/gs;
3316                         while ($s =~ /\n\s+\\\n/) {
3317                                 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3318                         }
3319
3320                         # We want to check the first line inside the block
3321                         # starting at the end of the conditional, so remove:
3322                         #  1) any blank line termination
3323                         #  2) any opening brace { on end of the line
3324                         #  3) any do (...) {
3325                         my $continuation = 0;
3326                         my $check = 0;
3327                         $s =~ s/^.*\bdo\b//;
3328                         $s =~ s/^\s*{//;
3329                         if ($s =~ s/^\s*\\//) {
3330                                 $continuation = 1;
3331                         }
3332                         if ($s =~ s/^\s*?\n//) {
3333                                 $check = 1;
3334                                 $cond_lines++;
3335                         }
3336
3337                         # Also ignore a loop construct at the end of a
3338                         # preprocessor statement.
3339                         if (($prevline =~ /^.\s*#\s*define\s/ ||
3340                             $prevline =~ /\\\s*$/) && $continuation == 0) {
3341                                 $check = 0;
3342                         }
3343
3344                         my $cond_ptr = -1;
3345                         $continuation = 0;
3346                         while ($cond_ptr != $cond_lines) {
3347                                 $cond_ptr = $cond_lines;
3348
3349                                 # If we see an #else/#elif then the code
3350                                 # is not linear.
3351                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3352                                         $check = 0;
3353                                 }
3354
3355                                 # Ignore:
3356                                 #  1) blank lines, they should be at 0,
3357                                 #  2) preprocessor lines, and
3358                                 #  3) labels.
3359                                 if ($continuation ||
3360                                     $s =~ /^\s*?\n/ ||
3361                                     $s =~ /^\s*#\s*?/ ||
3362                                     $s =~ /^\s*$Ident\s*:/) {
3363                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3364                                         if ($s =~ s/^.*?\n//) {
3365                                                 $cond_lines++;
3366                                         }
3367                                 }
3368                         }
3369
3370                         my (undef, $sindent) = line_stats("+" . $s);
3371                         my $stat_real = raw_line($linenr, $cond_lines);
3372
3373                         # Check if either of these lines are modified, else
3374                         # this is not this patch's fault.
3375                         if (!defined($stat_real) ||
3376                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3377                                 $check = 0;
3378                         }
3379                         if (defined($stat_real) && $cond_lines > 1) {
3380                                 $stat_real = "[...]\n$stat_real";
3381                         }
3382
3383                         #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";
3384
3385                         if ($check && $s ne '' &&
3386                             (($sindent % 8) != 0 ||
3387                              ($sindent < $indent) ||
3388                              ($sindent > $indent + 8))) {
3389                                 WARN("SUSPECT_CODE_INDENT",
3390                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3391                         }
3392                 }
3393
3394                 # Track the 'values' across context and added lines.
3395                 my $opline = $line; $opline =~ s/^./ /;
3396                 my ($curr_values, $curr_vars) =
3397                                 annotate_values($opline . "\n", $prev_values);
3398                 $curr_values = $prev_values . $curr_values;
3399                 if ($dbg_values) {
3400                         my $outline = $opline; $outline =~ s/\t/ /g;
3401                         print "$linenr > .$outline\n";
3402                         print "$linenr > $curr_values\n";
3403                         print "$linenr >  $curr_vars\n";
3404                 }
3405                 $prev_values = substr($curr_values, -1);
3406
3407 #ignore lines not being added
3408                 next if ($line =~ /^[^\+]/);
3409
3410 # check for declarations of signed or unsigned without int
3411                 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3412                         my $type = $1;
3413                         my $var = $2;
3414                         $var = "" if (!defined $var);
3415                         if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3416                                 my $sign = $1;
3417                                 my $pointer = $2;
3418
3419                                 $pointer = "" if (!defined $pointer);
3420
3421                                 if (WARN("UNSPECIFIED_INT",
3422                                          "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3423                                     $fix) {
3424                                         my $decl = trim($sign) . " int ";
3425                                         my $comp_pointer = $pointer;
3426                                         $comp_pointer =~ s/\s//g;
3427                                         $decl .= $comp_pointer;
3428                                         $decl = rtrim($decl) if ($var eq "");
3429                                         $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3430                                 }
3431                         }
3432                 }
3433
3434 # TEST: allow direct testing of the type matcher.
3435                 if ($dbg_type) {
3436                         if ($line =~ /^.\s*$Declare\s*$/) {
3437                                 ERROR("TEST_TYPE",
3438                                       "TEST: is type\n" . $herecurr);
3439                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3440                                 ERROR("TEST_NOT_TYPE",
3441                                       "TEST: is not type ($1 is)\n". $herecurr);
3442                         }
3443                         next;
3444                 }
3445 # TEST: allow direct testing of the attribute matcher.
3446                 if ($dbg_attr) {
3447                         if ($line =~ /^.\s*$Modifier\s*$/) {
3448                                 ERROR("TEST_ATTR",
3449                                       "TEST: is attr\n" . $herecurr);
3450                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3451                                 ERROR("TEST_NOT_ATTR",
3452                                       "TEST: is not attr ($1 is)\n". $herecurr);
3453                         }
3454                         next;
3455                 }
3456
3457 # check for initialisation to aggregates open brace on the next line
3458                 if ($line =~ /^.\s*{/ &&
3459                     $prevline =~ /(?:^|[^=])=\s*$/) {
3460                         if (ERROR("OPEN_BRACE",
3461                                   "that open brace { should be on the previous line\n" . $hereprev) &&
3462                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3463                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3464                                 fix_delete_line($fixlinenr, $rawline);
3465                                 my $fixedline = $prevrawline;
3466                                 $fixedline =~ s/\s*=\s*$/ = {/;
3467                                 fix_insert_line($fixlinenr, $fixedline);
3468                                 $fixedline = $line;
3469                                 $fixedline =~ s/^(.\s*){\s*/$1/;
3470                                 fix_insert_line($fixlinenr, $fixedline);
3471                         }
3472                 }
3473
3474 #
3475 # Checks which are anchored on the added line.
3476 #
3477
3478 # check for malformed paths in #include statements (uses RAW line)
3479                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3480                         my $path = $1;
3481                         if ($path =~ m{//}) {
3482                                 ERROR("MALFORMED_INCLUDE",
3483                                       "malformed #include filename\n" . $herecurr);
3484                         }
3485                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3486                                 ERROR("UAPI_INCLUDE",
3487                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3488                         }
3489                 }
3490
3491 # no C99 // comments
3492                 if ($line =~ m{//}) {
3493                         if (ERROR("C99_COMMENTS",
3494                                   "do not use C99 // comments\n" . $herecurr) &&
3495                             $fix) {
3496                                 my $line = $fixed[$fixlinenr];
3497                                 if ($line =~ /\/\/(.*)$/) {
3498                                         my $comment = trim($1);
3499                                         $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3500                                 }
3501                         }
3502                 }
3503                 # Remove C99 comments.
3504                 $line =~ s@//.*@@;
3505                 $opline =~ s@//.*@@;
3506
3507 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3508 # the whole statement.
3509 #print "APW <$lines[$realline_next - 1]>\n";
3510                 if (defined $realline_next &&
3511                     exists $lines[$realline_next - 1] &&
3512                     !defined $suppress_export{$realline_next} &&
3513                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3514                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3515                         # Handle definitions which produce identifiers with
3516                         # a prefix:
3517                         #   XXX(foo);
3518                         #   EXPORT_SYMBOL(something_foo);
3519                         my $name = $1;
3520                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3521                             $name =~ /^${Ident}_$2/) {
3522 #print "FOO C name<$name>\n";
3523                                 $suppress_export{$realline_next} = 1;
3524
3525                         } elsif ($stat !~ /(?:
3526                                 \n.}\s*$|
3527                                 ^.DEFINE_$Ident\(\Q$name\E\)|
3528                                 ^.DECLARE_$Ident\(\Q$name\E\)|
3529                                 ^.LIST_HEAD\(\Q$name\E\)|
3530                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3531                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3532                             )/x) {
3533 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3534                                 $suppress_export{$realline_next} = 2;
3535                         } else {
3536                                 $suppress_export{$realline_next} = 1;
3537                         }
3538                 }
3539                 if (!defined $suppress_export{$linenr} &&
3540                     $prevline =~ /^.\s*$/ &&
3541                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3542                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3543 #print "FOO B <$lines[$linenr - 1]>\n";
3544                         $suppress_export{$linenr} = 2;
3545                 }
3546                 if (defined $suppress_export{$linenr} &&
3547                     $suppress_export{$linenr} == 2) {
3548                         WARN("EXPORT_SYMBOL",
3549                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3550                 }
3551
3552 # check for global initialisers.
3553                 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3554                         if (ERROR("GLOBAL_INITIALISERS",
3555                                   "do not initialise globals to $1\n" . $herecurr) &&
3556                             $fix) {
3557                                 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3558                         }
3559                 }
3560 # check for static initialisers.
3561                 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3562                         if (ERROR("INITIALISED_STATIC",
3563                                   "do not initialise statics to $1\n" .
3564                                       $herecurr) &&
3565                             $fix) {
3566                                 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3567                         }
3568                 }
3569
3570 # check for misordered declarations of char/short/int/long with signed/unsigned
3571                 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3572                         my $tmp = trim($1);
3573                         WARN("MISORDERED_TYPE",
3574                              "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3575                 }
3576
3577 # check for static const char * arrays.
3578                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3579                         WARN("STATIC_CONST_CHAR_ARRAY",
3580                              "static const char * array should probably be static const char * const\n" .
3581                                 $herecurr);
3582                }
3583
3584 # check for static char foo[] = "bar" declarations.
3585                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3586                         WARN("STATIC_CONST_CHAR_ARRAY",
3587                              "static char array declaration should probably be static const char\n" .
3588                                 $herecurr);
3589                }
3590
3591 # check for const <foo> const where <foo> is not a pointer or array type
3592                 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3593                         my $found = $1;
3594                         if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3595                                 WARN("CONST_CONST",
3596                                      "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3597                         } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3598                                 WARN("CONST_CONST",
3599                                      "'const $found const' should probably be 'const $found'\n" . $herecurr);
3600                         }
3601                 }
3602
3603 # check for non-global char *foo[] = {"bar", ...} declarations.
3604                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3605                         WARN("STATIC_CONST_CHAR_ARRAY",
3606                              "char * array declaration might be better as static const\n" .
3607                                 $herecurr);
3608                }
3609
3610 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3611                 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3612                         my $array = $1;
3613                         if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3614                                 my $array_div = $1;
3615                                 if (WARN("ARRAY_SIZE",
3616                                          "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3617                                     $fix) {
3618                                         $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3619                                 }
3620                         }
3621                 }
3622
3623 # check for function declarations without arguments like "int foo()"
3624                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3625                         if (ERROR("FUNCTION_WITHOUT_ARGS",
3626                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3627                             $fix) {
3628                                 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3629                         }
3630                 }
3631
3632 # check for new typedefs, only function parameters and sparse annotations
3633 # make sense.
3634                 if ($line =~ /\btypedef\s/ &&
3635                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3636                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3637                     $line !~ /\b$typeTypedefs\b/ &&
3638                     $line !~ /\b__bitwise(?:__|)\b/) {
3639                         WARN("NEW_TYPEDEFS",
3640                              "do not add new typedefs\n" . $herecurr);
3641                 }
3642
3643 # * goes on variable not on type
3644                 # (char*[ const])
3645                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3646                         #print "AA<$1>\n";
3647                         my ($ident, $from, $to) = ($1, $2, $2);
3648
3649                         # Should start with a space.
3650                         $to =~ s/^(\S)/ $1/;
3651                         # Should not end with a space.
3652                         $to =~ s/\s+$//;
3653                         # '*'s should not have spaces between.
3654                         while ($to =~ s/\*\s+\*/\*\*/) {
3655                         }
3656
3657 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
3658                         if ($from ne $to) {
3659                                 if (ERROR("POINTER_LOCATION",
3660                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3661                                     $fix) {
3662                                         my $sub_from = $ident;
3663                                         my $sub_to = $ident;
3664                                         $sub_to =~ s/\Q$from\E/$to/;
3665                                         $fixed[$fixlinenr] =~
3666                                             s@\Q$sub_from\E@$sub_to@;
3667                                 }
3668                         }
3669                 }
3670                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3671                         #print "BB<$1>\n";
3672                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3673
3674                         # Should start with a space.
3675                         $to =~ s/^(\S)/ $1/;
3676                         # Should not end with a space.
3677                         $to =~ s/\s+$//;
3678                         # '*'s should not have spaces between.
3679                         while ($to =~ s/\*\s+\*/\*\*/) {
3680                         }
3681                         # Modifiers should have spaces.
3682                         $to =~ s/(\b$Modifier$)/$1 /;
3683
3684 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
3685                         if ($from ne $to && $ident !~ /^$Modifier$/) {
3686                                 if (ERROR("POINTER_LOCATION",
3687                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3688                                     $fix) {
3689
3690                                         my $sub_from = $match;
3691                                         my $sub_to = $match;
3692                                         $sub_to =~ s/\Q$from\E/$to/;
3693                                         $fixed[$fixlinenr] =~
3694                                             s@\Q$sub_from\E@$sub_to@;
3695                                 }
3696                         }
3697                 }
3698
3699 # avoid BUG() or BUG_ON()
3700                 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3701                         my $msg_type = \&WARN;
3702                         $msg_type = \&CHK if ($file);
3703                         &{$msg_type}("AVOID_BUG",
3704                                      "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3705                 }
3706
3707 # avoid LINUX_VERSION_CODE
3708                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3709                         WARN("LINUX_VERSION_CODE",
3710                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3711                 }
3712
3713 # check for uses of printk_ratelimit
3714                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3715                         WARN("PRINTK_RATELIMITED",
3716                              "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3717                 }
3718
3719 # printk should use KERN_* levels.  Note that follow on printk's on the
3720 # same line do not need a level, so we use the current block context
3721 # to try and find and validate the current printk.  In summary the current
3722 # printk includes all preceding printk's which have no newline on the end.
3723 # we assume the first bad printk is the one to report.
3724                 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3725                         my $ok = 0;
3726                         for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3727                                 #print "CHECK<$lines[$ln - 1]\n";
3728                                 # we have a preceding printk if it ends
3729                                 # with "\n" ignore it, else it is to blame
3730                                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3731                                         if ($rawlines[$ln - 1] !~ m{\\n"}) {
3732                                                 $ok = 1;
3733                                         }
3734                                         last;
3735                                 }
3736                         }
3737                         if ($ok == 0) {
3738                                 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3739                                      "printk() should include KERN_ facility level\n" . $herecurr);
3740                         }
3741                 }
3742
3743                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3744                         my $orig = $1;
3745                         my $level = lc($orig);
3746                         $level = "warn" if ($level eq "warning");
3747                         my $level2 = $level;
3748                         $level2 = "dbg" if ($level eq "debug");
3749                         WARN("PREFER_PR_LEVEL",
3750                              "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3751                 }
3752
3753                 if ($line =~ /\bpr_warning\s*\(/) {
3754                         if (WARN("PREFER_PR_LEVEL",
3755                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3756                             $fix) {
3757                                 $fixed[$fixlinenr] =~
3758                                     s/\bpr_warning\b/pr_warn/;
3759                         }
3760                 }
3761
3762                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3763                         my $orig = $1;
3764                         my $level = lc($orig);
3765                         $level = "warn" if ($level eq "warning");
3766                         $level = "dbg" if ($level eq "debug");
3767                         WARN("PREFER_DEV_LEVEL",
3768                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3769                 }
3770
3771 # ENOSYS means "bad syscall nr" and nothing else.  This will have a small
3772 # number of false positives, but assembly files are not checked, so at
3773 # least the arch entry code will not trigger this warning.
3774                 if ($line =~ /\bENOSYS\b/) {
3775                         WARN("ENOSYS",
3776                              "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3777                 }
3778
3779 # function brace can't be on same line, except for #defines of do while,
3780 # or if closed on same line
3781                 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3782                     !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3783                         if (ERROR("OPEN_BRACE",
3784                                   "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3785                             $fix) {
3786                                 fix_delete_line($fixlinenr, $rawline);
3787                                 my $fixed_line = $rawline;
3788                                 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3789                                 my $line1 = $1;
3790                                 my $line2 = $2;
3791                                 fix_insert_line($fixlinenr, ltrim($line1));
3792                                 fix_insert_line($fixlinenr, "\+{");
3793                                 if ($line2 !~ /^\s*$/) {
3794                                         fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3795                                 }
3796                         }
3797                 }
3798
3799 # open braces for enum, union and struct go on the same line.
3800                 if ($line =~ /^.\s*{/ &&
3801                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3802                         if (ERROR("OPEN_BRACE",
3803                                   "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3804                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3805                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3806                                 fix_delete_line($fixlinenr, $rawline);
3807                                 my $fixedline = rtrim($prevrawline) . " {";
3808                                 fix_insert_line($fixlinenr, $fixedline);
3809                                 $fixedline = $rawline;
3810                                 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3811                                 if ($fixedline !~ /^\+\s*$/) {
3812                                         fix_insert_line($fixlinenr, $fixedline);
3813                                 }
3814                         }
3815                 }
3816
3817 # missing space after union, struct or enum definition
3818                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3819                         if (WARN("SPACING",
3820                                  "missing space after $1 definition\n" . $herecurr) &&
3821                             $fix) {
3822                                 $fixed[$fixlinenr] =~
3823                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3824                         }
3825                 }
3826
3827 # Function pointer declarations
3828 # check spacing between type, funcptr, and args
3829 # canonical declaration is "type (*funcptr)(args...)"
3830                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3831                         my $declare = $1;
3832                         my $pre_pointer_space = $2;
3833                         my $post_pointer_space = $3;
3834                         my $funcname = $4;
3835                         my $post_funcname_space = $5;
3836                         my $pre_args_space = $6;
3837
3838 # the $Declare variable will capture all spaces after the type
3839 # so check it for a missing trailing missing space but pointer return types
3840 # don't need a space so don't warn for those.
3841                         my $post_declare_space = "";
3842                         if ($declare =~ /(\s+)$/) {
3843                                 $post_declare_space = $1;
3844                                 $declare = rtrim($declare);
3845                         }
3846                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3847                                 WARN("SPACING",
3848                                      "missing space after return type\n" . $herecurr);
3849                                 $post_declare_space = " ";
3850                         }
3851
3852 # unnecessary space "type  (*funcptr)(args...)"
3853 # This test is not currently implemented because these declarations are
3854 # equivalent to
3855 #       int  foo(int bar, ...)
3856 # and this is form shouldn't/doesn't generate a checkpatch warning.
3857 #
3858 #                       elsif ($declare =~ /\s{2,}$/) {
3859 #                               WARN("SPACING",
3860 #                                    "Multiple spaces after return type\n" . $herecurr);
3861 #                       }
3862
3863 # unnecessary space "type ( *funcptr)(args...)"
3864                         if (defined $pre_pointer_space &&
3865                             $pre_pointer_space =~ /^\s/) {
3866                                 WARN("SPACING",
3867                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3868                         }
3869
3870 # unnecessary space "type (* funcptr)(args...)"
3871                         if (defined $post_pointer_space &&
3872                             $post_pointer_space =~ /^\s/) {
3873                                 WARN("SPACING",
3874                                      "Unnecessary space before function pointer name\n" . $herecurr);
3875                         }
3876
3877 # unnecessary space "type (*funcptr )(args...)"
3878                         if (defined $post_funcname_space &&
3879                             $post_funcname_space =~ /^\s/) {
3880                                 WARN("SPACING",
3881                                      "Unnecessary space after function pointer name\n" . $herecurr);
3882                         }
3883
3884 # unnecessary space "type (*funcptr) (args...)"
3885                         if (defined $pre_args_space &&
3886                             $pre_args_space =~ /^\s/) {
3887                                 WARN("SPACING",
3888                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
3889                         }
3890
3891                         if (show_type("SPACING") && $fix) {
3892                                 $fixed[$fixlinenr] =~
3893                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3894                         }
3895                 }
3896
3897 # check for spacing round square brackets; allowed:
3898 #  1. with a type on the left -- int [] a;
3899 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3900 #  3. inside a curly brace -- = { [0...10] = 5 }
3901                 while ($line =~ /(.*?\s)\[/g) {
3902                         my ($where, $prefix) = ($-[1], $1);
3903                         if ($prefix !~ /$Type\s+$/ &&
3904                             ($where != 0 || $prefix !~ /^.\s+$/) &&
3905                             $prefix !~ /[{,]\s+$/) {
3906                                 if (ERROR("BRACKET_SPACE",
3907                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
3908                                     $fix) {
3909                                     $fixed[$fixlinenr] =~
3910                                         s/^(\+.*?)\s+\[/$1\[/;
3911                                 }
3912                         }
3913                 }
3914
3915 # check for spaces between functions and their parentheses.
3916                 while ($line =~ /($Ident)\s+\(/g) {
3917                         my $name = $1;
3918                         my $ctx_before = substr($line, 0, $-[1]);
3919                         my $ctx = "$ctx_before$name";
3920
3921                         # Ignore those directives where spaces _are_ permitted.
3922                         if ($name =~ /^(?:
3923                                 if|for|while|switch|return|case|
3924                                 volatile|__volatile__|
3925                                 __attribute__|format|__extension__|
3926                                 asm|__asm__)$/x)
3927                         {
3928                         # cpp #define statements have non-optional spaces, ie
3929                         # if there is a space between the name and the open
3930                         # parenthesis it is simply not a parameter group.
3931                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3932
3933                         # cpp #elif statement condition may start with a (
3934                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3935
3936                         # If this whole things ends with a type its most
3937                         # likely a typedef for a function.
3938                         } elsif ($ctx =~ /$Type$/) {
3939
3940                         } else {
3941                                 if (WARN("SPACING",
3942                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3943                                              $fix) {
3944                                         $fixed[$fixlinenr] =~
3945                                             s/\b$name\s+\(/$name\(/;
3946                                 }
3947                         }
3948                 }
3949
3950 # Check operator spacing.
3951                 if (!($line=~/\#\s*include/)) {
3952                         my $fixed_line = "";
3953                         my $line_fixed = 0;
3954
3955                         my $ops = qr{
3956                                 <<=|>>=|<=|>=|==|!=|
3957                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3958                                 =>|->|<<|>>|<|>|=|!|~|
3959                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3960                                 \?:|\?|:
3961                         }x;
3962                         my @elements = split(/($ops|;)/, $opline);
3963
3964 ##                      print("element count: <" . $#elements . ">\n");
3965 ##                      foreach my $el (@elements) {
3966 ##                              print("el: <$el>\n");
3967 ##                      }
3968
3969                         my @fix_elements = ();
3970                         my $off = 0;
3971
3972                         foreach my $el (@elements) {
3973                                 push(@fix_elements, substr($rawline, $off, length($el)));
3974                                 $off += length($el);
3975                         }
3976
3977                         $off = 0;
3978
3979                         my $blank = copy_spacing($opline);
3980                         my $last_after = -1;
3981
3982                         for (my $n = 0; $n < $#elements; $n += 2) {
3983
3984                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3985
3986 ##                              print("n: <$n> good: <$good>\n");
3987
3988                                 $off += length($elements[$n]);
3989
3990                                 # Pick up the preceding and succeeding characters.
3991                                 my $ca = substr($opline, 0, $off);
3992                                 my $cc = '';
3993                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3994                                         $cc = substr($opline, $off + length($elements[$n + 1]));
3995                                 }
3996                                 my $cb = "$ca$;$cc";
3997
3998                                 my $a = '';
3999                                 $a = 'V' if ($elements[$n] ne '');
4000                                 $a = 'W' if ($elements[$n] =~ /\s$/);
4001                                 $a = 'C' if ($elements[$n] =~ /$;$/);
4002                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4003                                 $a = 'O' if ($elements[$n] eq '');
4004                                 $a = 'E' if ($ca =~ /^\s*$/);
4005
4006                                 my $op = $elements[$n + 1];
4007
4008                                 my $c = '';
4009                                 if (defined $elements[$n + 2]) {
4010                                         $c = 'V' if ($elements[$n + 2] ne '');
4011                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4012                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4013                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4014                                         $c = 'O' if ($elements[$n + 2] eq '');
4015                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4016                                 } else {
4017                                         $c = 'E';
4018                                 }
4019
4020                                 my $ctx = "${a}x${c}";
4021
4022                                 my $at = "(ctx:$ctx)";
4023
4024                                 my $ptr = substr($blank, 0, $off) . "^";
4025                                 my $hereptr = "$hereline$ptr\n";
4026
4027                                 # Pull out the value of this operator.
4028                                 my $op_type = substr($curr_values, $off + 1, 1);
4029
4030                                 # Get the full operator variant.
4031                                 my $opv = $op . substr($curr_vars, $off, 1);
4032
4033                                 # Ignore operators passed as parameters.
4034                                 if ($op_type ne 'V' &&
4035                                     $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4036
4037 #                               # Ignore comments
4038 #                               } elsif ($op =~ /^$;+$/) {
4039
4040                                 # ; should have either the end of line or a space or \ after it
4041                                 } elsif ($op eq ';') {
4042                                         if ($ctx !~ /.x[WEBC]/ &&
4043                                             $cc !~ /^\\/ && $cc !~ /^;/) {
4044                                                 if (ERROR("SPACING",
4045                                                           "space required after that '$op' $at\n" . $hereptr)) {
4046                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4047                                                         $line_fixed = 1;
4048                                                 }
4049                                         }
4050
4051                                 # // is a comment
4052                                 } elsif ($op eq '//') {
4053
4054                                 #   :   when part of a bitfield
4055                                 } elsif ($opv eq ':B') {
4056                                         # skip the bitfield test for now
4057
4058                                 # No spaces for:
4059                                 #   ->
4060                                 } elsif ($op eq '->') {
4061                                         if ($ctx =~ /Wx.|.xW/) {
4062                                                 if (ERROR("SPACING",
4063                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4064                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4065                                                         if (defined $fix_elements[$n + 2]) {
4066                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4067                                                         }
4068                                                         $line_fixed = 1;
4069                                                 }
4070                                         }
4071
4072                                 # , must not have a space before and must have a space on the right.
4073                                 } elsif ($op eq ',') {
4074                                         my $rtrim_before = 0;
4075                                         my $space_after = 0;
4076                                         if ($ctx =~ /Wx./) {
4077                                                 if (ERROR("SPACING",
4078                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
4079                                                         $line_fixed = 1;
4080                                                         $rtrim_before = 1;
4081                                                 }
4082                                         }
4083                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4084                                                 if (ERROR("SPACING",
4085                                                           "space required after that '$op' $at\n" . $hereptr)) {
4086                                                         $line_fixed = 1;
4087                                                         $last_after = $n;
4088                                                         $space_after = 1;
4089                                                 }
4090                                         }
4091                                         if ($rtrim_before || $space_after) {
4092                                                 if ($rtrim_before) {
4093                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4094                                                 } else {
4095                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4096                                                 }
4097                                                 if ($space_after) {
4098                                                         $good .= " ";
4099                                                 }
4100                                         }
4101
4102                                 # '*' as part of a type definition -- reported already.
4103                                 } elsif ($opv eq '*_') {
4104                                         #warn "'*' is part of type\n";
4105
4106                                 # unary operators should have a space before and
4107                                 # none after.  May be left adjacent to another
4108                                 # unary operator, or a cast
4109                                 } elsif ($op eq '!' || $op eq '~' ||
4110                                          $opv eq '*U' || $opv eq '-U' ||
4111                                          $opv eq '&U' || $opv eq '&&U') {
4112                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4113                                                 if (ERROR("SPACING",
4114                                                           "space required before that '$op' $at\n" . $hereptr)) {
4115                                                         if ($n != $last_after + 2) {
4116                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4117                                                                 $line_fixed = 1;
4118                                                         }
4119                                                 }
4120                                         }
4121                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4122                                                 # A unary '*' may be const
4123
4124                                         } elsif ($ctx =~ /.xW/) {
4125                                                 if (ERROR("SPACING",
4126                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
4127                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4128                                                         if (defined $fix_elements[$n + 2]) {
4129                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4130                                                         }
4131                                                         $line_fixed = 1;
4132                                                 }
4133                                         }
4134
4135                                 # unary ++ and unary -- are allowed no space on one side.
4136                                 } elsif ($op eq '++' or $op eq '--') {
4137                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4138                                                 if (ERROR("SPACING",
4139                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
4140                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4141                                                         $line_fixed = 1;
4142                                                 }
4143                                         }
4144                                         if ($ctx =~ /Wx[BE]/ ||
4145                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4146                                                 if (ERROR("SPACING",
4147                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
4148                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4149                                                         $line_fixed = 1;
4150                                                 }
4151                                         }
4152                                         if ($ctx =~ /ExW/) {
4153                                                 if (ERROR("SPACING",
4154                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
4155                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4156                                                         if (defined $fix_elements[$n + 2]) {
4157                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4158                                                         }
4159                                                         $line_fixed = 1;
4160                                                 }
4161                                         }
4162
4163                                 # << and >> may either have or not have spaces both sides
4164                                 } elsif ($op eq '<<' or $op eq '>>' or
4165                                          $op eq '&' or $op eq '^' or $op eq '|' or
4166                                          $op eq '+' or $op eq '-' or
4167                                          $op eq '*' or $op eq '/' or
4168                                          $op eq '%')
4169                                 {
4170                                         if ($check) {
4171                                                 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4172                                                         if (CHK("SPACING",
4173                                                                 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4174                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4175                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4176                                                                 $line_fixed = 1;
4177                                                         }
4178                                                 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4179                                                         if (CHK("SPACING",
4180                                                                 "space preferred before that '$op' $at\n" . $hereptr)) {
4181                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4182                                                                 $line_fixed = 1;
4183                                                         }
4184                                                 }
4185                                         } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4186                                                 if (ERROR("SPACING",
4187                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
4188                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4189                                                         if (defined $fix_elements[$n + 2]) {
4190                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4191                                                         }
4192                                                         $line_fixed = 1;
4193                                                 }
4194                                         }
4195
4196                                 # A colon needs no spaces before when it is
4197                                 # terminating a case value or a label.
4198                                 } elsif ($opv eq ':C' || $opv eq ':L') {
4199                                         if ($ctx =~ /Wx./) {
4200                                                 if (ERROR("SPACING",
4201                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
4202                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4203                                                         $line_fixed = 1;
4204                                                 }
4205                                         }
4206
4207                                 # All the others need spaces both sides.
4208                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4209                                         my $ok = 0;
4210
4211                                         # Ignore email addresses <foo@bar>
4212                                         if (($op eq '<' &&
4213                                              $cc =~ /^\S+\@\S+>/) ||
4214                                             ($op eq '>' &&
4215                                              $ca =~ /<\S+\@\S+$/))
4216                                         {
4217                                                 $ok = 1;
4218                                         }
4219
4220                                         # for asm volatile statements
4221                                         # ignore a colon with another
4222                                         # colon immediately before or after
4223                                         if (($op eq ':') &&
4224                                             ($ca =~ /:$/ || $cc =~ /^:/)) {
4225                                                 $ok = 1;
4226                                         }
4227
4228                                         # messages are ERROR, but ?: are CHK
4229                                         if ($ok == 0) {
4230                                                 my $msg_type = \&ERROR;
4231                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4232
4233                                                 if (&{$msg_type}("SPACING",
4234                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {
4235                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4236                                                         if (defined $fix_elements[$n + 2]) {
4237                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4238                                                         }
4239                                                         $line_fixed = 1;
4240                                                 }
4241                                         }
4242                                 }
4243                                 $off += length($elements[$n + 1]);
4244
4245 ##                              print("n: <$n> GOOD: <$good>\n");
4246
4247                                 $fixed_line = $fixed_line . $good;
4248                         }
4249
4250                         if (($#elements % 2) == 0) {
4251                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
4252                         }
4253
4254                         if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4255                                 $fixed[$fixlinenr] = $fixed_line;
4256                         }
4257
4258
4259                 }
4260
4261 # check for whitespace before a non-naked semicolon
4262                 if ($line =~ /^\+.*\S\s+;\s*$/) {
4263                         if (WARN("SPACING",
4264                                  "space prohibited before semicolon\n" . $herecurr) &&
4265                             $fix) {
4266                                 1 while $fixed[$fixlinenr] =~
4267                                     s/^(\+.*\S)\s+;/$1;/;
4268                         }
4269                 }
4270
4271 # check for multiple assignments
4272                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4273                         CHK("MULTIPLE_ASSIGNMENTS",
4274                             "multiple assignments should be avoided\n" . $herecurr);
4275                 }
4276
4277 ## # check for multiple declarations, allowing for a function declaration
4278 ## # continuation.
4279 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4280 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4281 ##
4282 ##                      # Remove any bracketed sections to ensure we do not
4283 ##                      # falsly report the parameters of functions.
4284 ##                      my $ln = $line;
4285 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
4286 ##                      }
4287 ##                      if ($ln =~ /,/) {
4288 ##                              WARN("MULTIPLE_DECLARATION",
4289 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
4290 ##                      }
4291 ##              }
4292
4293 #need space before brace following if, while, etc
4294                 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4295                     $line =~ /do\{/) {
4296                         if (ERROR("SPACING",
4297                                   "space required before the open brace '{'\n" . $herecurr) &&
4298                             $fix) {
4299                                 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4300                         }
4301                 }
4302
4303 ## # check for blank lines before declarations
4304 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4305 ##                  $prevrawline =~ /^.\s*$/) {
4306 ##                      WARN("SPACING",
4307 ##                           "No blank lines before declarations\n" . $hereprev);
4308 ##              }
4309 ##
4310
4311 # closing brace should have a space following it when it has anything
4312 # on the line
4313                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4314                         if (ERROR("SPACING",
4315                                   "space required after that close brace '}'\n" . $herecurr) &&
4316                             $fix) {
4317                                 $fixed[$fixlinenr] =~
4318                                     s/}((?!(?:,|;|\)))\S)/} $1/;
4319                         }
4320                 }
4321
4322 # check spacing on square brackets
4323                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4324                         if (ERROR("SPACING",
4325                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
4326                             $fix) {
4327                                 $fixed[$fixlinenr] =~
4328                                     s/\[\s+/\[/;
4329                         }
4330                 }
4331                 if ($line =~ /\s\]/) {
4332                         if (ERROR("SPACING",
4333                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4334                             $fix) {
4335                                 $fixed[$fixlinenr] =~
4336                                     s/\s+\]/\]/;
4337                         }
4338                 }
4339
4340 # check spacing on parentheses
4341                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4342                     $line !~ /for\s*\(\s+;/) {
4343                         if (ERROR("SPACING",
4344                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4345                             $fix) {
4346                                 $fixed[$fixlinenr] =~
4347                                     s/\(\s+/\(/;
4348                         }
4349                 }
4350                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4351                     $line !~ /for\s*\(.*;\s+\)/ &&
4352                     $line !~ /:\s+\)/) {
4353                         if (ERROR("SPACING",
4354                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4355                             $fix) {
4356                                 $fixed[$fixlinenr] =~
4357                                     s/\s+\)/\)/;
4358                         }
4359                 }
4360
4361 # check unnecessary parentheses around addressof/dereference single $Lvals
4362 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4363
4364                 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4365                         my $var = $1;
4366                         if (CHK("UNNECESSARY_PARENTHESES",
4367                                 "Unnecessary parentheses around $var\n" . $herecurr) &&
4368                             $fix) {
4369                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4370                         }
4371                 }
4372
4373 # check for unnecessary parentheses around function pointer uses
4374 # ie: (foo->bar)(); should be foo->bar();
4375 # but not "if (foo->bar) (" to avoid some false positives
4376                 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4377                         my $var = $2;
4378                         if (CHK("UNNECESSARY_PARENTHESES",
4379                                 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4380                             $fix) {
4381                                 my $var2 = deparenthesize($var);
4382                                 $var2 =~ s/\s//g;
4383                                 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4384                         }
4385                 }
4386
4387 #goto labels aren't indented, allow a single space however
4388                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4389                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4390                         if (WARN("INDENTED_LABEL",
4391                                  "labels should not be indented\n" . $herecurr) &&
4392                             $fix) {
4393                                 $fixed[$fixlinenr] =~
4394                                     s/^(.)\s+/$1/;
4395                         }
4396                 }
4397
4398 # return is not a function
4399                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4400                         my $spacing = $1;
4401                         if ($^V && $^V ge 5.10.0 &&
4402                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4403                                 my $value = $1;
4404                                 $value = deparenthesize($value);
4405                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4406                                         ERROR("RETURN_PARENTHESES",
4407                                               "return is not a function, parentheses are not required\n" . $herecurr);
4408                                 }
4409                         } elsif ($spacing !~ /\s+/) {
4410                                 ERROR("SPACING",
4411                                       "space required before the open parenthesis '('\n" . $herecurr);
4412                         }
4413                 }
4414
4415 # unnecessary return in a void function
4416 # at end-of-function, with the previous line a single leading tab, then return;
4417 # and the line before that not a goto label target like "out:"
4418                 if ($sline =~ /^[ \+]}\s*$/ &&
4419                     $prevline =~ /^\+\treturn\s*;\s*$/ &&
4420                     $linenr >= 3 &&
4421                     $lines[$linenr - 3] =~ /^[ +]/ &&
4422                     $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4423                         WARN("RETURN_VOID",
4424                              "void function return statements are not generally useful\n" . $hereprev);
4425                }
4426
4427 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4428                 if ($^V && $^V ge 5.10.0 &&
4429                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
4430                         my $openparens = $1;
4431                         my $count = $openparens =~ tr@\(@\(@;
4432                         my $msg = "";
4433                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4434                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
4435                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
4436                                 WARN("UNNECESSARY_PARENTHESES",
4437                                      "Unnecessary parentheses$msg\n" . $herecurr);
4438                         }
4439                 }
4440
4441 # comparisons with a constant or upper case identifier on the left
4442 #       avoid cases like "foo + BAR < baz"
4443 #       only fix matches surrounded by parentheses to avoid incorrect
4444 #       conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4445                 if ($^V && $^V ge 5.10.0 &&
4446                     $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4447                         my $lead = $1;
4448                         my $const = $2;
4449                         my $comp = $3;
4450                         my $to = $4;
4451                         my $newcomp = $comp;
4452                         if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4453                             $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4454                             WARN("CONSTANT_COMPARISON",
4455                                  "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4456                             $fix) {
4457                                 if ($comp eq "<") {
4458                                         $newcomp = ">";
4459                                 } elsif ($comp eq "<=") {
4460                                         $newcomp = ">=";
4461                                 } elsif ($comp eq ">") {
4462                                         $newcomp = "<";
4463                                 } elsif ($comp eq ">=") {
4464                                         $newcomp = "<=";
4465                                 }
4466                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4467                         }
4468                 }
4469
4470 # Return of what appears to be an errno should normally be negative
4471                 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4472                         my $name = $1;
4473                         if ($name ne 'EOF' && $name ne 'ERROR') {
4474                                 WARN("USE_NEGATIVE_ERRNO",
4475                                      "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4476                         }
4477                 }
4478
4479 # Need a space before open parenthesis after if, while etc
4480                 if ($line =~ /\b(if|while|for|switch)\(/) {
4481                         if (ERROR("SPACING",
4482                                   "space required before the open parenthesis '('\n" . $herecurr) &&
4483                             $fix) {
4484                                 $fixed[$fixlinenr] =~
4485                                     s/\b(if|while|for|switch)\(/$1 \(/;
4486                         }
4487                 }
4488
4489 # Check for illegal assignment in if conditional -- and check for trailing
4490 # statements after the conditional.
4491                 if ($line =~ /do\s*(?!{)/) {
4492                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4493                                 ctx_statement_block($linenr, $realcnt, 0)
4494                                         if (!defined $stat);
4495                         my ($stat_next) = ctx_statement_block($line_nr_next,
4496                                                 $remain_next, $off_next);
4497                         $stat_next =~ s/\n./\n /g;
4498                         ##print "stat<$stat> stat_next<$stat_next>\n";
4499
4500                         if ($stat_next =~ /^\s*while\b/) {
4501                                 # If the statement carries leading newlines,
4502                                 # then count those as offsets.
4503                                 my ($whitespace) =
4504                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4505                                 my $offset =
4506                                         statement_rawlines($whitespace) - 1;
4507
4508                                 $suppress_whiletrailers{$line_nr_next +
4509                                                                 $offset} = 1;
4510                         }
4511                 }
4512                 if (!defined $suppress_whiletrailers{$linenr} &&
4513                     defined($stat) && defined($cond) &&
4514                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4515                         my ($s, $c) = ($stat, $cond);
4516
4517                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4518                                 ERROR("ASSIGN_IN_IF",
4519                                       "do not use assignment in if condition\n" . $herecurr);
4520                         }
4521
4522                         # Find out what is on the end of the line after the
4523                         # conditional.
4524                         substr($s, 0, length($c), '');
4525                         $s =~ s/\n.*//g;
4526                         $s =~ s/$;//g;  # Remove any comments
4527                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4528                             $c !~ /}\s*while\s*/)
4529                         {
4530                                 # Find out how long the conditional actually is.
4531                                 my @newlines = ($c =~ /\n/gs);
4532                                 my $cond_lines = 1 + $#newlines;
4533                                 my $stat_real = '';
4534
4535                                 $stat_real = raw_line($linenr, $cond_lines)
4536                                                         . "\n" if ($cond_lines);
4537                                 if (defined($stat_real) && $cond_lines > 1) {
4538                                         $stat_real = "[...]\n$stat_real";
4539                                 }
4540
4541                                 ERROR("TRAILING_STATEMENTS",
4542                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
4543                         }
4544                 }
4545
4546 # Check for bitwise tests written as boolean
4547                 if ($line =~ /
4548                         (?:
4549                                 (?:\[|\(|\&\&|\|\|)
4550                                 \s*0[xX][0-9]+\s*
4551                                 (?:\&\&|\|\|)
4552                         |
4553                                 (?:\&\&|\|\|)
4554                                 \s*0[xX][0-9]+\s*
4555                                 (?:\&\&|\|\||\)|\])
4556                         )/x)
4557                 {
4558                         WARN("HEXADECIMAL_BOOLEAN_TEST",
4559                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4560                 }
4561
4562 # if and else should not have general statements after it
4563                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4564                         my $s = $1;
4565                         $s =~ s/$;//g;  # Remove any comments
4566                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4567                                 ERROR("TRAILING_STATEMENTS",
4568                                       "trailing statements should be on next line\n" . $herecurr);
4569                         }
4570                 }
4571 # if should not continue a brace
4572                 if ($line =~ /}\s*if\b/) {
4573                         ERROR("TRAILING_STATEMENTS",
4574                               "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4575                                 $herecurr);
4576                 }
4577 # case and default should not have general statements after them
4578                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4579                     $line !~ /\G(?:
4580                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4581                         \s*return\s+
4582                     )/xg)
4583                 {
4584                         ERROR("TRAILING_STATEMENTS",
4585                               "trailing statements should be on next line\n" . $herecurr);
4586                 }
4587
4588                 # Check for }<nl>else {, these must be at the same
4589                 # indent level to be relevant to each other.
4590                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4591                     $previndent == $indent) {
4592                         if (ERROR("ELSE_AFTER_BRACE",
4593                                   "else should follow close brace '}'\n" . $hereprev) &&
4594                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4595                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4596                                 fix_delete_line($fixlinenr, $rawline);
4597                                 my $fixedline = $prevrawline;
4598                                 $fixedline =~ s/}\s*$//;
4599                                 if ($fixedline !~ /^\+\s*$/) {
4600                                         fix_insert_line($fixlinenr, $fixedline);
4601                                 }
4602                                 $fixedline = $rawline;
4603                                 $fixedline =~ s/^(.\s*)else/$1} else/;
4604                                 fix_insert_line($fixlinenr, $fixedline);
4605                         }
4606                 }
4607
4608                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4609                     $previndent == $indent) {
4610                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4611
4612                         # Find out what is on the end of the line after the
4613                         # conditional.
4614                         substr($s, 0, length($c), '');
4615                         $s =~ s/\n.*//g;
4616
4617                         if ($s =~ /^\s*;/) {
4618                                 if (ERROR("WHILE_AFTER_BRACE",
4619                                           "while should follow close brace '}'\n" . $hereprev) &&
4620                                     $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4621                                         fix_delete_line($fixlinenr - 1, $prevrawline);
4622                                         fix_delete_line($fixlinenr, $rawline);
4623                                         my $fixedline = $prevrawline;
4624                                         my $trailing = $rawline;
4625                                         $trailing =~ s/^\+//;
4626                                         $trailing = trim($trailing);
4627                                         $fixedline =~ s/}\s*$/} $trailing/;
4628                                         fix_insert_line($fixlinenr, $fixedline);
4629                                 }
4630                         }
4631                 }
4632
4633 #Specific variable tests
4634                 while ($line =~ m{($Constant|$Lval)}g) {
4635                         my $var = $1;
4636
4637 #gcc binary extension
4638                         if ($var =~ /^$Binary$/) {
4639                                 if (WARN("GCC_BINARY_CONSTANT",
4640                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4641                                     $fix) {
4642                                         my $hexval = sprintf("0x%x", oct($var));
4643                                         $fixed[$fixlinenr] =~
4644                                             s/\b$var\b/$hexval/;
4645                                 }
4646                         }
4647
4648 #CamelCase
4649                         if ($var !~ /^$Constant$/ &&
4650                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4651 #Ignore Page<foo> variants
4652                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4653 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4654                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4655 #Ignore some three character SI units explicitly, like MiB and KHz
4656                             $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4657                                 while ($var =~ m{($Ident)}g) {
4658                                         my $word = $1;
4659                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4660                                         if ($check) {
4661                                                 seed_camelcase_includes();
4662                                                 if (!$file && !$camelcase_file_seeded) {
4663                                                         seed_camelcase_file($realfile);
4664                                                         $camelcase_file_seeded = 1;
4665                                                 }
4666                                         }
4667                                         if (!defined $camelcase{$word}) {
4668                                                 $camelcase{$word} = 1;
4669                                                 CHK("CAMELCASE",
4670                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
4671                                         }
4672                                 }
4673                         }
4674                 }
4675
4676 #no spaces allowed after \ in define
4677                 if ($line =~ /\#\s*define.*\\\s+$/) {
4678                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4679                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4680                             $fix) {
4681                                 $fixed[$fixlinenr] =~ s/\s+$//;
4682                         }
4683                 }
4684
4685 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4686 # itself <asm/foo.h> (uses RAW line)
4687                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4688                         my $file = "$1.h";
4689                         my $checkfile = "include/linux/$file";
4690                         if (-f "$root/$checkfile" &&
4691                             $realfile ne $checkfile &&
4692                             $1 !~ /$allowed_asm_includes/)
4693                         {
4694                                 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4695                                 if ($asminclude > 0) {
4696                                         if ($realfile =~ m{^arch/}) {
4697                                                 CHK("ARCH_INCLUDE_LINUX",
4698                                                     "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4699                                         } else {
4700                                                 WARN("INCLUDE_LINUX",
4701                                                      "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4702                                         }
4703                                 }
4704                         }
4705                 }
4706
4707 # multi-statement macros should be enclosed in a do while loop, grab the
4708 # first statement and ensure its the whole macro if its not enclosed
4709 # in a known good container
4710                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4711                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4712                         my $ln = $linenr;
4713                         my $cnt = $realcnt;
4714                         my ($off, $dstat, $dcond, $rest);
4715                         my $ctx = '';
4716                         my $has_flow_statement = 0;
4717                         my $has_arg_concat = 0;
4718                         ($dstat, $dcond, $ln, $cnt, $off) =
4719                                 ctx_statement_block($linenr, $realcnt, 0);
4720                         $ctx = $dstat;
4721                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4722                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4723
4724                         $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4725                         $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4726
4727                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4728                         $dstat =~ s/$;//g;
4729                         $dstat =~ s/\\\n.//g;
4730                         $dstat =~ s/^\s*//s;
4731                         $dstat =~ s/\s*$//s;
4732
4733                         # Flatten any parentheses and braces
4734                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4735                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
4736                                $dstat =~ s/.\[[^\[\]]*\]/1/)
4737                         {
4738                         }
4739
4740                         # Flatten any obvious string concatentation.
4741                         while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4742                                $dstat =~ s/$Ident\s*($String)/$1/)
4743                         {
4744                         }
4745
4746                         # Make asm volatile uses seem like a generic function
4747                         $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4748
4749                         my $exceptions = qr{
4750                                 $Declare|
4751                                 module_param_named|
4752                                 MODULE_PARM_DESC|
4753                                 DECLARE_PER_CPU|
4754                                 DEFINE_PER_CPU|
4755                                 __typeof__\(|
4756                                 union|
4757                                 struct|
4758                                 \.$Ident\s*=\s*|
4759                                 ^\"|\"$|
4760                                 ^\[
4761                         }x;
4762                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4763                         if ($dstat ne '' &&
4764                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
4765                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
4766                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4767                             $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&                  # character constants
4768                             $dstat !~ /$exceptions/ &&
4769                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
4770                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
4771                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
4772                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
4773                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
4774                             $dstat !~ /^do\s*{/ &&                                      # do {...
4775                             $dstat !~ /^\(\{/ &&                                                # ({...
4776                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4777                         {
4778                                 $ctx =~ s/\n*$//;
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
4786                                 if ($dstat =~ /;/) {
4787                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4788                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4789                                 } else {
4790                                         ERROR("COMPLEX_MACRO",
4791                                               "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4792                                 }
4793                         }
4794
4795 # check for macros with flow control, but without ## concatenation
4796 # ## concatenation is commonly a macro that defines a function so ignore those
4797                         if ($has_flow_statement && !$has_arg_concat) {
4798                                 my $herectx = $here . "\n";
4799                                 my $cnt = statement_rawlines($ctx);
4800
4801                                 for (my $n = 0; $n < $cnt; $n++) {
4802                                         $herectx .= raw_line($linenr, $n) . "\n";
4803                                 }
4804                                 WARN("MACRO_WITH_FLOW_CONTROL",
4805                                      "Macros with flow control statements should be avoided\n" . "$herectx");
4806                         }
4807
4808 # check for line continuations outside of #defines, preprocessor #, and asm
4809
4810                 } else {
4811                         if ($prevline !~ /^..*\\$/ &&
4812                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
4813                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
4814                             $line =~ /^\+.*\\$/) {
4815                                 WARN("LINE_CONTINUATIONS",
4816                                      "Avoid unnecessary line continuations\n" . $herecurr);
4817                         }
4818                 }
4819
4820 # do {} while (0) macro tests:
4821 # single-statement macros do not need to be enclosed in do while (0) loop,
4822 # macro should not end with a semicolon
4823                 if ($^V && $^V ge 5.10.0 &&
4824                     $realfile !~ m@/vmlinux.lds.h$@ &&
4825                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4826                         my $ln = $linenr;
4827                         my $cnt = $realcnt;
4828                         my ($off, $dstat, $dcond, $rest);
4829                         my $ctx = '';
4830                         ($dstat, $dcond, $ln, $cnt, $off) =
4831                                 ctx_statement_block($linenr, $realcnt, 0);
4832                         $ctx = $dstat;
4833
4834                         $dstat =~ s/\\\n.//g;
4835                         $dstat =~ s/$;/ /g;
4836
4837                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4838                                 my $stmts = $2;
4839                                 my $semis = $3;
4840
4841                                 $ctx =~ s/\n*$//;
4842                                 my $cnt = statement_rawlines($ctx);
4843                                 my $herectx = $here . "\n";
4844
4845                                 for (my $n = 0; $n < $cnt; $n++) {
4846                                         $herectx .= raw_line($linenr, $n) . "\n";
4847                                 }
4848
4849                                 if (($stmts =~ tr/;/;/) == 1 &&
4850                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
4851                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4852                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4853                                 }
4854                                 if (defined $semis && $semis ne "") {
4855                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4856                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4857                                 }
4858                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4859                                 $ctx =~ s/\n*$//;
4860                                 my $cnt = statement_rawlines($ctx);
4861                                 my $herectx = $here . "\n";
4862
4863                                 for (my $n = 0; $n < $cnt; $n++) {
4864                                         $herectx .= raw_line($linenr, $n) . "\n";
4865                                 }
4866
4867                                 WARN("TRAILING_SEMICOLON",
4868                                      "macros should not use a trailing semicolon\n" . "$herectx");
4869                         }
4870                 }
4871
4872 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4873 # all assignments may have only one of the following with an assignment:
4874 #       .
4875 #       ALIGN(...)
4876 #       VMLINUX_SYMBOL(...)
4877                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4878                         WARN("MISSING_VMLINUX_SYMBOL",
4879                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4880                 }
4881
4882 # check for redundant bracing round if etc
4883                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4884                         my ($level, $endln, @chunks) =
4885                                 ctx_statement_full($linenr, $realcnt, 1);
4886                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4887                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4888                         if ($#chunks > 0 && $level == 0) {
4889                                 my @allowed = ();
4890                                 my $allow = 0;
4891                                 my $seen = 0;
4892                                 my $herectx = $here . "\n";
4893                                 my $ln = $linenr - 1;
4894                                 for my $chunk (@chunks) {
4895                                         my ($cond, $block) = @{$chunk};
4896
4897                                         # If the condition carries leading newlines, then count those as offsets.
4898                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4899                                         my $offset = statement_rawlines($whitespace) - 1;
4900
4901                                         $allowed[$allow] = 0;
4902                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4903
4904                                         # We have looked at and allowed this specific line.
4905                                         $suppress_ifbraces{$ln + $offset} = 1;
4906
4907                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4908                                         $ln += statement_rawlines($block) - 1;
4909
4910                                         substr($block, 0, length($cond), '');
4911
4912                                         $seen++ if ($block =~ /^\s*{/);
4913
4914                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4915                                         if (statement_lines($cond) > 1) {
4916                                                 #print "APW: ALLOWED: cond<$cond>\n";
4917                                                 $allowed[$allow] = 1;
4918                                         }
4919                                         if ($block =~/\b(?:if|for|while)\b/) {
4920                                                 #print "APW: ALLOWED: block<$block>\n";
4921                                                 $allowed[$allow] = 1;
4922                                         }
4923                                         if (statement_block_size($block) > 1) {
4924                                                 #print "APW: ALLOWED: lines block<$block>\n";
4925                                                 $allowed[$allow] = 1;
4926                                         }
4927                                         $allow++;
4928                                 }
4929                                 if ($seen) {
4930                                         my $sum_allowed = 0;
4931                                         foreach (@allowed) {
4932                                                 $sum_allowed += $_;
4933                                         }
4934                                         if ($sum_allowed == 0) {
4935                                                 WARN("BRACES",
4936                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
4937                                         } elsif ($sum_allowed != $allow &&
4938                                                  $seen != $allow) {
4939                                                 CHK("BRACES",
4940                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
4941                                         }
4942                                 }
4943                         }
4944                 }
4945                 if (!defined $suppress_ifbraces{$linenr - 1} &&
4946                                         $line =~ /\b(if|while|for|else)\b/) {
4947                         my $allowed = 0;
4948
4949                         # Check the pre-context.
4950                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4951                                 #print "APW: ALLOWED: pre<$1>\n";
4952                                 $allowed = 1;
4953                         }
4954
4955                         my ($level, $endln, @chunks) =
4956                                 ctx_statement_full($linenr, $realcnt, $-[0]);
4957
4958                         # Check the condition.
4959                         my ($cond, $block) = @{$chunks[0]};
4960                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4961                         if (defined $cond) {
4962                                 substr($block, 0, length($cond), '');
4963                         }
4964                         if (statement_lines($cond) > 1) {
4965                                 #print "APW: ALLOWED: cond<$cond>\n";
4966                                 $allowed = 1;
4967                         }
4968                         if ($block =~/\b(?:if|for|while)\b/) {
4969                                 #print "APW: ALLOWED: block<$block>\n";
4970                                 $allowed = 1;
4971                         }
4972                         if (statement_block_size($block) > 1) {
4973                                 #print "APW: ALLOWED: lines block<$block>\n";
4974                                 $allowed = 1;
4975                         }
4976                         # Check the post-context.
4977                         if (defined $chunks[1]) {
4978                                 my ($cond, $block) = @{$chunks[1]};
4979                                 if (defined $cond) {
4980                                         substr($block, 0, length($cond), '');
4981                                 }
4982                                 if ($block =~ /^\s*\{/) {
4983                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
4984                                         $allowed = 1;
4985                                 }
4986                         }
4987                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4988                                 my $herectx = $here . "\n";
4989                                 my $cnt = statement_rawlines($block);
4990
4991                                 for (my $n = 0; $n < $cnt; $n++) {
4992                                         $herectx .= raw_line($linenr, $n) . "\n";
4993                                 }
4994
4995                                 WARN("BRACES",
4996                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
4997                         }
4998                 }
4999
5000 # check for unnecessary blank lines around braces
5001                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5002                         if (CHK("BRACES",
5003                                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5004                             $fix && $prevrawline =~ /^\+/) {
5005                                 fix_delete_line($fixlinenr - 1, $prevrawline);
5006                         }
5007                 }
5008                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5009                         if (CHK("BRACES",
5010                                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5011                             $fix) {
5012                                 fix_delete_line($fixlinenr, $rawline);
5013                         }
5014                 }
5015
5016 # no volatiles please
5017                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5018                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5019                         WARN("VOLATILE",
5020                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
5021                 }
5022
5023 # Check for user-visible strings broken across lines, which breaks the ability
5024 # to grep for the string.  Make exceptions when the previous string ends in a
5025 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5026 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5027                 if ($line =~ /^\+\s*$String/ &&
5028                     $prevline =~ /"\s*$/ &&
5029                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5030                         if (WARN("SPLIT_STRING",
5031                                  "quoted string split across lines\n" . $hereprev) &&
5032                                      $fix &&
5033                                      $prevrawline =~ /^\+.*"\s*$/ &&
5034                                      $last_coalesced_string_linenr != $linenr - 1) {
5035                                 my $extracted_string = get_quoted_string($line, $rawline);
5036                                 my $comma_close = "";
5037                                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5038                                         $comma_close = $1;
5039                                 }
5040
5041                                 fix_delete_line($fixlinenr - 1, $prevrawline);
5042                                 fix_delete_line($fixlinenr, $rawline);
5043                                 my $fixedline = $prevrawline;
5044                                 $fixedline =~ s/"\s*$//;
5045                                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5046                                 fix_insert_line($fixlinenr - 1, $fixedline);
5047                                 $fixedline = $rawline;
5048                                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5049                                 if ($fixedline !~ /\+\s*$/) {
5050                                         fix_insert_line($fixlinenr, $fixedline);
5051                                 }
5052                                 $last_coalesced_string_linenr = $linenr;
5053                         }
5054                 }
5055
5056 # check for missing a space in a string concatenation
5057                 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5058                         WARN('MISSING_SPACE',
5059                              "break quoted strings at a space character\n" . $hereprev);
5060                 }
5061
5062 # check for spaces before a quoted newline
5063                 if ($rawline =~ /^.*\".*\s\\n/) {
5064                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5065                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5066                             $fix) {
5067                                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5068                         }
5069
5070                 }
5071
5072 # concatenated string without spaces between elements
5073                 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5074                         CHK("CONCATENATED_STRING",
5075                             "Concatenated strings should use spaces between elements\n" . $herecurr);
5076                 }
5077
5078 # uncoalesced string fragments
5079                 if ($line =~ /$String\s*"/) {
5080                         WARN("STRING_FRAGMENTS",
5081                              "Consecutive strings are generally better as a single string\n" . $herecurr);
5082                 }
5083
5084 # check for %L{u,d,i} and 0x%[udi] in strings
5085                 my $string;
5086                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5087                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
5088                         $string =~ s/%%/__/g;
5089                         if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
5090                                 WARN("PRINTF_L",
5091                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5092                                 last;
5093                         }
5094                         if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5095                                 ERROR("PRINTF_0xDECIMAL",
5096                                       "Prefixing 0x with decimal output is defective\n" . $herecurr);
5097                         }
5098                 }
5099
5100 # check for line continuations in quoted strings with odd counts of "
5101                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5102                         WARN("LINE_CONTINUATIONS",
5103                              "Avoid line continuations in quoted strings\n" . $herecurr);
5104                 }
5105
5106 # warn about #if 0
5107                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5108                         CHK("REDUNDANT_CODE",
5109                             "if this code is redundant consider removing it\n" .
5110                                 $herecurr);
5111                 }
5112
5113 # check for needless "if (<foo>) fn(<foo>)" uses
5114                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5115                         my $tested = quotemeta($1);
5116                         my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5117                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5118                                 my $func = $1;
5119                                 if (WARN('NEEDLESS_IF',
5120                                          "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5121                                     $fix) {
5122                                         my $do_fix = 1;
5123                                         my $leading_tabs = "";
5124                                         my $new_leading_tabs = "";
5125                                         if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5126                                                 $leading_tabs = $1;
5127                                         } else {
5128                                                 $do_fix = 0;
5129                                         }
5130                                         if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5131                                                 $new_leading_tabs = $1;
5132                                                 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5133                                                         $do_fix = 0;
5134                                                 }
5135                                         } else {
5136                                                 $do_fix = 0;
5137                                         }
5138                                         if ($do_fix) {
5139                                                 fix_delete_line($fixlinenr - 1, $prevrawline);
5140                                                 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5141                                         }
5142                                 }
5143                         }
5144                 }
5145
5146 # check for unnecessary "Out of Memory" messages
5147                 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5148                     $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5149                     (defined $1 || defined $3) &&
5150                     $linenr > 3) {
5151                         my $testval = $2;
5152                         my $testline = $lines[$linenr - 3];
5153
5154                         my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5155 #                       print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5156
5157                         if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5158                                 WARN("OOM_MESSAGE",
5159                                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
5160                         }
5161                 }
5162
5163 # check for logging functions with KERN_<LEVEL>
5164                 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5165                     $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5166                         my $level = $1;
5167                         if (WARN("UNNECESSARY_KERN_LEVEL",
5168                                  "Possible unnecessary $level\n" . $herecurr) &&
5169                             $fix) {
5170                                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5171                         }
5172                 }
5173
5174 # check for mask then right shift without a parentheses
5175                 if ($^V && $^V ge 5.10.0 &&
5176                     $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5177                     $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5178                         WARN("MASK_THEN_SHIFT",
5179                              "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5180                 }
5181
5182 # check for pointer comparisons to NULL
5183                 if ($^V && $^V ge 5.10.0) {
5184                         while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5185                                 my $val = $1;
5186                                 my $equal = "!";
5187                                 $equal = "" if ($4 eq "!=");
5188                                 if (CHK("COMPARISON_TO_NULL",
5189                                         "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5190                                             $fix) {
5191                                         $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5192                                 }
5193                         }
5194                 }
5195
5196 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5197                 if ($line =~ /(\b$InitAttribute\b)/) {
5198                         my $attr = $1;
5199                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5200                                 my $ptr = $1;
5201                                 my $var = $2;
5202                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5203                                       ERROR("MISPLACED_INIT",
5204                                             "$attr should be placed after $var\n" . $herecurr)) ||
5205                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5206                                       WARN("MISPLACED_INIT",
5207                                            "$attr should be placed after $var\n" . $herecurr))) &&
5208                                     $fix) {
5209                                         $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;
5210                                 }
5211                         }
5212                 }
5213
5214 # check for $InitAttributeData (ie: __initdata) with const
5215                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5216                         my $attr = $1;
5217                         $attr =~ /($InitAttributePrefix)(.*)/;
5218                         my $attr_prefix = $1;
5219                         my $attr_type = $2;
5220                         if (ERROR("INIT_ATTRIBUTE",
5221                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5222                             $fix) {
5223                                 $fixed[$fixlinenr] =~
5224                                     s/$InitAttributeData/${attr_prefix}initconst/;
5225                         }
5226                 }
5227
5228 # check for $InitAttributeConst (ie: __initconst) without const
5229                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5230                         my $attr = $1;
5231                         if (ERROR("INIT_ATTRIBUTE",
5232                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
5233                             $fix) {
5234                                 my $lead = $fixed[$fixlinenr] =~
5235                                     /(^\+\s*(?:static\s+))/;
5236                                 $lead = rtrim($1);
5237                                 $lead = "$lead " if ($lead !~ /^\+$/);
5238                                 $lead = "${lead}const ";
5239                                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5240                         }
5241                 }
5242
5243 # check for __read_mostly with const non-pointer (should just be const)
5244                 if ($line =~ /\b__read_mostly\b/ &&
5245                     $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5246                         if (ERROR("CONST_READ_MOSTLY",
5247                                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5248                             $fix) {
5249                                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5250                         }
5251                 }
5252
5253 # don't use __constant_<foo> functions outside of include/uapi/
5254                 if ($realfile !~ m@^include/uapi/@ &&
5255                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5256                         my $constant_func = $1;
5257                         my $func = $constant_func;
5258                         $func =~ s/^__constant_//;
5259                         if (WARN("CONSTANT_CONVERSION",
5260                                  "$constant_func should be $func\n" . $herecurr) &&
5261                             $fix) {
5262                                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5263                         }
5264                 }
5265
5266 # prefer usleep_range over udelay
5267                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5268                         my $delay = $1;
5269                         # ignore udelay's < 10, however
5270                         if (! ($delay < 10) ) {
5271                                 CHK("USLEEP_RANGE",
5272                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5273                         }
5274                         if ($delay > 2000) {
5275                                 WARN("LONG_UDELAY",
5276                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5277                         }
5278                 }
5279
5280 # warn about unexpectedly long msleep's
5281                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5282                         if ($1 < 20) {
5283                                 WARN("MSLEEP",
5284                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5285                         }
5286                 }
5287
5288 # check for comparisons of jiffies
5289                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5290                         WARN("JIFFIES_COMPARISON",
5291                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5292                 }
5293
5294 # check for comparisons of get_jiffies_64()
5295                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5296                         WARN("JIFFIES_COMPARISON",
5297                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5298                 }
5299
5300 # warn about #ifdefs in C files
5301 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5302 #                       print "#ifdef in C files should be avoided\n";
5303 #                       print "$herecurr";
5304 #                       $clean = 0;
5305 #               }
5306
5307 # warn about spacing in #ifdefs
5308                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5309                         if (ERROR("SPACING",
5310                                   "exactly one space required after that #$1\n" . $herecurr) &&
5311                             $fix) {
5312                                 $fixed[$fixlinenr] =~
5313                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5314                         }
5315
5316                 }
5317
5318 # check for spinlock_t definitions without a comment.
5319                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5320                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5321                         my $which = $1;
5322                         if (!ctx_has_comment($first_line, $linenr)) {
5323                                 CHK("UNCOMMENTED_DEFINITION",
5324                                     "$1 definition without comment\n" . $herecurr);
5325                         }
5326                 }
5327 # check for memory barriers without a comment.
5328
5329                 my $barriers = qr{
5330                         mb|
5331                         rmb|
5332                         wmb|
5333                         read_barrier_depends
5334                 }x;
5335                 my $barrier_stems = qr{
5336                         mb__before_atomic|
5337                         mb__after_atomic|
5338                         store_release|
5339                         load_acquire|
5340                         store_mb|
5341                         (?:$barriers)
5342                 }x;
5343                 my $all_barriers = qr{
5344                         (?:$barriers)|
5345                         smp_(?:$barrier_stems)|
5346                         virt_(?:$barrier_stems)
5347                 }x;
5348
5349                 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5350                         if (!ctx_has_comment($first_line, $linenr)) {
5351                                 WARN("MEMORY_BARRIER",
5352                                      "memory barrier without comment\n" . $herecurr);
5353                         }
5354                 }
5355
5356                 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5357
5358                 if ($realfile !~ m@^include/asm-generic/@ &&
5359                     $realfile !~ m@/barrier\.h$@ &&
5360                     $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5361                     $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5362                         WARN("MEMORY_BARRIER",
5363                              "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5364                 }
5365
5366 # check for waitqueue_active without a comment.
5367                 if ($line =~ /\bwaitqueue_active\s*\(/) {
5368                         if (!ctx_has_comment($first_line, $linenr)) {
5369                                 WARN("WAITQUEUE_ACTIVE",
5370                                      "waitqueue_active without comment\n" . $herecurr);
5371                         }
5372                 }
5373
5374 # Check for expedited grace periods that interrupt non-idle non-nohz
5375 # online CPUs.  These expedited can therefore degrade real-time response
5376 # if used carelessly, and should be avoided where not absolutely
5377 # needed.  It is always OK to use synchronize_rcu_expedited() and
5378 # synchronize_sched_expedited() at boot time (before real-time applications
5379 # start) and in error situations where real-time response is compromised in
5380 # any case.  Note that synchronize_srcu_expedited() does -not- interrupt
5381 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5382 # Of course, nothing comes for free, and srcu_read_lock() and
5383 # srcu_read_unlock() do contain full memory barriers in payment for
5384 # synchronize_srcu_expedited() non-interruption properties.
5385                 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5386                         WARN("EXPEDITED_RCU_GRACE_PERIOD",
5387                              "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5388
5389                 }
5390
5391 # check of hardware specific defines
5392                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5393                         CHK("ARCH_DEFINES",
5394                             "architecture specific defines should be avoided\n" .  $herecurr);
5395                 }
5396
5397 # Check that the storage class is at the beginning of a declaration
5398                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5399                         WARN("STORAGE_CLASS",
5400                              "storage class should be at the beginning of the declaration\n" . $herecurr)
5401                 }
5402
5403 # check the location of the inline attribute, that it is between
5404 # storage class and type.
5405                 if ($line =~ /\b$Type\s+$Inline\b/ ||
5406                     $line =~ /\b$Inline\s+$Storage\b/) {
5407                         ERROR("INLINE_LOCATION",
5408                               "inline keyword should sit between storage class and type\n" . $herecurr);
5409                 }
5410
5411 # Check for __inline__ and __inline, prefer inline
5412                 if ($realfile !~ m@\binclude/uapi/@ &&
5413                     $line =~ /\b(__inline__|__inline)\b/) {
5414                         if (WARN("INLINE",
5415                                  "plain inline is preferred over $1\n" . $herecurr) &&
5416                             $fix) {
5417                                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5418
5419                         }
5420                 }
5421
5422 # Check for __attribute__ packed, prefer __packed
5423                 if ($realfile !~ m@\binclude/uapi/@ &&
5424                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5425                         WARN("PREFER_PACKED",
5426                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5427                 }
5428
5429 # Check for __attribute__ aligned, prefer __aligned
5430                 if ($realfile !~ m@\binclude/uapi/@ &&
5431                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5432                         WARN("PREFER_ALIGNED",
5433                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5434                 }
5435
5436 # Check for __attribute__ format(printf, prefer __printf
5437                 if ($realfile !~ m@\binclude/uapi/@ &&
5438                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5439                         if (WARN("PREFER_PRINTF",
5440                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5441                             $fix) {
5442                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5443
5444                         }
5445                 }
5446
5447 # Check for __attribute__ format(scanf, prefer __scanf
5448                 if ($realfile !~ m@\binclude/uapi/@ &&
5449                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5450                         if (WARN("PREFER_SCANF",
5451                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5452                             $fix) {
5453                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5454                         }
5455                 }
5456
5457 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5458                 if ($^V && $^V ge 5.10.0 &&
5459                     $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5460                     ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5461                      $line =~ /\b__weak\b/)) {
5462                         ERROR("WEAK_DECLARATION",
5463                               "Using weak declarations can have unintended link defects\n" . $herecurr);
5464                 }
5465
5466 # check for c99 types like uint8_t used outside of uapi/
5467                 if ($realfile !~ m@\binclude/uapi/@ &&
5468                     $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5469                         my $type = $1;
5470                         if ($type =~ /\b($typeC99Typedefs)\b/) {
5471                                 $type = $1;
5472                                 my $kernel_type = 'u';
5473                                 $kernel_type = 's' if ($type =~ /^_*[si]/);
5474                                 $type =~ /(\d+)/;
5475                                 $kernel_type .= $1;
5476                                 if (CHK("PREFER_KERNEL_TYPES",
5477                                         "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5478                                     $fix) {
5479                                         $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5480                                 }
5481                         }
5482                 }
5483
5484 # check for cast of C90 native int or longer types constants
5485                 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5486                         my $cast = $1;
5487                         my $const = $2;
5488                         if (WARN("TYPECAST_INT_CONSTANT",
5489                                  "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5490                             $fix) {
5491                                 my $suffix = "";
5492                                 my $newconst = $const;
5493                                 $newconst =~ s/${Int_type}$//;
5494                                 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5495                                 if ($cast =~ /\blong\s+long\b/) {
5496                                         $suffix .= 'LL';
5497                                 } elsif ($cast =~ /\blong\b/) {
5498                                         $suffix .= 'L';
5499                                 }
5500                                 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5501                         }
5502                 }
5503
5504 # check for sizeof(&)
5505                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5506                         WARN("SIZEOF_ADDRESS",
5507                              "sizeof(& should be avoided\n" . $herecurr);
5508                 }
5509
5510 # check for sizeof without parenthesis
5511                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5512                         if (WARN("SIZEOF_PARENTHESIS",
5513                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5514                             $fix) {
5515                                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5516                         }
5517                 }
5518
5519 # check for struct spinlock declarations
5520                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5521                         WARN("USE_SPINLOCK_T",
5522                              "struct spinlock should be spinlock_t\n" . $herecurr);
5523                 }
5524
5525 # check for seq_printf uses that could be seq_puts
5526                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5527                         my $fmt = get_quoted_string($line, $rawline);
5528                         $fmt =~ s/%%//g;
5529                         if ($fmt !~ /%/) {
5530                                 if (WARN("PREFER_SEQ_PUTS",
5531                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5532                                     $fix) {
5533                                         $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5534                                 }
5535                         }
5536                 }
5537
5538 # Check for misused memsets
5539                 if ($^V && $^V ge 5.10.0 &&
5540                     defined $stat &&
5541                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5542
5543                         my $ms_addr = $2;
5544                         my $ms_val = $7;
5545                         my $ms_size = $12;
5546
5547                         if ($ms_size =~ /^(0x|)0$/i) {
5548                                 ERROR("MEMSET",
5549                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5550                         } elsif ($ms_size =~ /^(0x|)1$/i) {
5551                                 WARN("MEMSET",
5552                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5553                         }
5554                 }
5555
5556 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5557 #               if ($^V && $^V ge 5.10.0 &&
5558 #                   defined $stat &&
5559 #                   $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5560 #                       if (WARN("PREFER_ETHER_ADDR_COPY",
5561 #                                "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5562 #                           $fix) {
5563 #                               $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5564 #                       }
5565 #               }
5566
5567 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5568 #               if ($^V && $^V ge 5.10.0 &&
5569 #                   defined $stat &&
5570 #                   $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5571 #                       WARN("PREFER_ETHER_ADDR_EQUAL",
5572 #                            "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5573 #               }
5574
5575 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5576 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5577 #               if ($^V && $^V ge 5.10.0 &&
5578 #                   defined $stat &&
5579 #                   $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5580 #
5581 #                       my $ms_val = $7;
5582 #
5583 #                       if ($ms_val =~ /^(?:0x|)0+$/i) {
5584 #                               if (WARN("PREFER_ETH_ZERO_ADDR",
5585 #                                        "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5586 #                                   $fix) {
5587 #                                       $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5588 #                               }
5589 #                       } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5590 #                               if (WARN("PREFER_ETH_BROADCAST_ADDR",
5591 #                                        "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5592 #                                   $fix) {
5593 #                                       $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5594 #                               }
5595 #                       }
5596 #               }
5597
5598 # typecasts on min/max could be min_t/max_t
5599                 if ($^V && $^V ge 5.10.0 &&
5600                     defined $stat &&
5601                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5602                         if (defined $2 || defined $7) {
5603                                 my $call = $1;
5604                                 my $cast1 = deparenthesize($2);
5605                                 my $arg1 = $3;
5606                                 my $cast2 = deparenthesize($7);
5607                                 my $arg2 = $8;
5608                                 my $cast;
5609
5610                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5611                                         $cast = "$cast1 or $cast2";
5612                                 } elsif ($cast1 ne "") {
5613                                         $cast = $cast1;
5614                                 } else {
5615                                         $cast = $cast2;
5616                                 }
5617                                 WARN("MINMAX",
5618                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5619                         }
5620                 }
5621
5622 # check usleep_range arguments
5623                 if ($^V && $^V ge 5.10.0 &&
5624                     defined $stat &&
5625                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5626                         my $min = $1;
5627                         my $max = $7;
5628                         if ($min eq $max) {
5629                                 WARN("USLEEP_RANGE",
5630                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5631                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5632                                  $min > $max) {
5633                                 WARN("USLEEP_RANGE",
5634                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5635                         }
5636                 }
5637
5638 # check for naked sscanf
5639                 if ($^V && $^V ge 5.10.0 &&
5640                     defined $stat &&
5641                     $line =~ /\bsscanf\b/ &&
5642                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5643                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5644                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5645                         my $lc = $stat =~ tr@\n@@;
5646                         $lc = $lc + $linenr;
5647                         my $stat_real = raw_line($linenr, 0);
5648                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5649                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5650                         }
5651                         WARN("NAKED_SSCANF",
5652                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5653                 }
5654
5655 # check for simple sscanf that should be kstrto<foo>
5656                 if ($^V && $^V ge 5.10.0 &&
5657                     defined $stat &&
5658                     $line =~ /\bsscanf\b/) {
5659                         my $lc = $stat =~ tr@\n@@;
5660                         $lc = $lc + $linenr;
5661                         my $stat_real = raw_line($linenr, 0);
5662                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5663                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5664                         }
5665                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5666                                 my $format = $6;
5667                                 my $count = $format =~ tr@%@%@;
5668                                 if ($count == 1 &&
5669                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5670                                         WARN("SSCANF_TO_KSTRTO",
5671                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5672                                 }
5673                         }
5674                 }
5675
5676 # check for new externs in .h files.
5677                 if ($realfile =~ /\.h$/ &&
5678                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5679                         if (CHK("AVOID_EXTERNS",
5680                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5681                             $fix) {
5682                                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5683                         }
5684                 }
5685
5686 # check for new externs in .c files.
5687                 if ($realfile =~ /\.c$/ && defined $stat &&
5688                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5689                 {
5690                         my $function_name = $1;
5691                         my $paren_space = $2;
5692
5693                         my $s = $stat;
5694                         if (defined $cond) {
5695                                 substr($s, 0, length($cond), '');
5696                         }
5697                         if ($s =~ /^\s*;/ &&
5698                             $function_name ne 'uninitialized_var')
5699                         {
5700                                 WARN("AVOID_EXTERNS",
5701                                      "externs should be avoided in .c files\n" .  $herecurr);
5702                         }
5703
5704                         if ($paren_space =~ /\n/) {
5705                                 WARN("FUNCTION_ARGUMENTS",
5706                                      "arguments for function declarations should follow identifier\n" . $herecurr);
5707                         }
5708
5709                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5710                     $stat =~ /^.\s*extern\s+/)
5711                 {
5712                         WARN("AVOID_EXTERNS",
5713                              "externs should be avoided in .c files\n" .  $herecurr);
5714                 }
5715
5716 # checks for new __setup's
5717                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5718                         my $name = $1;
5719
5720                         if (!grep(/$name/, @setup_docs)) {
5721                                 CHK("UNDOCUMENTED_SETUP",
5722                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5723                         }
5724                 }
5725
5726 # check for pointless casting of kmalloc return
5727                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5728                         WARN("UNNECESSARY_CASTS",
5729                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5730                 }
5731
5732 # alloc style
5733 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5734                 if ($^V && $^V ge 5.10.0 &&
5735                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5736                         CHK("ALLOC_SIZEOF_STRUCT",
5737                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5738                 }
5739
5740 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5741                 if ($^V && $^V ge 5.10.0 &&
5742                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5743                         my $oldfunc = $3;
5744                         my $a1 = $4;
5745                         my $a2 = $10;
5746                         my $newfunc = "kmalloc_array";
5747                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5748                         my $r1 = $a1;
5749                         my $r2 = $a2;
5750                         if ($a1 =~ /^sizeof\s*\S/) {
5751                                 $r1 = $a2;
5752                                 $r2 = $a1;
5753                         }
5754                         if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5755                             !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5756                                 if (WARN("ALLOC_WITH_MULTIPLY",
5757                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5758                                     $fix) {
5759                                         $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;
5760
5761                                 }
5762                         }
5763                 }
5764
5765 # check for krealloc arg reuse
5766                 if ($^V && $^V ge 5.10.0 &&
5767                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5768                         WARN("KREALLOC_ARG_REUSE",
5769                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5770                 }
5771
5772 # check for alloc argument mismatch
5773                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5774                         WARN("ALLOC_ARRAY_ARGS",
5775                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5776                 }
5777
5778 # check for multiple semicolons
5779                 if ($line =~ /;\s*;\s*$/) {
5780                         if (WARN("ONE_SEMICOLON",
5781                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
5782                             $fix) {
5783                                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5784                         }
5785                 }
5786
5787 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
5788                 if ($realfile !~ m@^include/uapi/@ &&
5789                     $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5790                         my $ull = "";
5791                         $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5792                         if (CHK("BIT_MACRO",
5793                                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5794                             $fix) {
5795                                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5796                         }
5797                 }
5798
5799 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5800                 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5801                         my $config = $1;
5802                         if (WARN("PREFER_IS_ENABLED",
5803                                  "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5804                             $fix) {
5805                                 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5806                         }
5807                 }
5808
5809 # check for case / default statements not preceded by break/fallthrough/switch
5810                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5811                         my $has_break = 0;
5812                         my $has_statement = 0;
5813                         my $count = 0;
5814                         my $prevline = $linenr;
5815                         while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5816                                 $prevline--;
5817                                 my $rline = $rawlines[$prevline - 1];
5818                                 my $fline = $lines[$prevline - 1];
5819                                 last if ($fline =~ /^\@\@/);
5820                                 next if ($fline =~ /^\-/);
5821                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5822                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5823                                 next if ($fline =~ /^.[\s$;]*$/);
5824                                 $has_statement = 1;
5825                                 $count++;
5826                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5827                         }
5828                         if (!$has_break && $has_statement) {
5829                                 WARN("MISSING_BREAK",
5830                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5831                         }
5832                 }
5833
5834 # check for switch/default statements without a break;
5835                 if ($^V && $^V ge 5.10.0 &&
5836                     defined $stat &&
5837                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5838                         my $ctx = '';
5839                         my $herectx = $here . "\n";
5840                         my $cnt = statement_rawlines($stat);
5841                         for (my $n = 0; $n < $cnt; $n++) {
5842                                 $herectx .= raw_line($linenr, $n) . "\n";
5843                         }
5844                         WARN("DEFAULT_NO_BREAK",
5845                              "switch default: should use break\n" . $herectx);
5846                 }
5847
5848 # check for gcc specific __FUNCTION__
5849                 if ($line =~ /\b__FUNCTION__\b/) {
5850                         if (WARN("USE_FUNC",
5851                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
5852                             $fix) {
5853                                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5854                         }
5855                 }
5856
5857 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5858                 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5859                         ERROR("DATE_TIME",
5860                               "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5861                 }
5862
5863 # check for use of yield()
5864                 if ($line =~ /\byield\s*\(\s*\)/) {
5865                         WARN("YIELD",
5866                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
5867                 }
5868
5869 # check for comparisons against true and false
5870                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5871                         my $lead = $1;
5872                         my $arg = $2;
5873                         my $test = $3;
5874                         my $otype = $4;
5875                         my $trail = $5;
5876                         my $op = "!";
5877
5878                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5879
5880                         my $type = lc($otype);
5881                         if ($type =~ /^(?:true|false)$/) {
5882                                 if (("$test" eq "==" && "$type" eq "true") ||
5883                                     ("$test" eq "!=" && "$type" eq "false")) {
5884                                         $op = "";
5885                                 }
5886
5887                                 CHK("BOOL_COMPARISON",
5888                                     "Using comparison to $otype is error prone\n" . $herecurr);
5889
5890 ## maybe suggesting a correct construct would better
5891 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5892
5893                         }
5894                 }
5895
5896 # check for semaphores initialized locked
5897                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5898                         WARN("CONSIDER_COMPLETION",
5899                              "consider using a completion\n" . $herecurr);
5900                 }
5901
5902 # recommend kstrto* over simple_strto* and strict_strto*
5903                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5904                         WARN("CONSIDER_KSTRTO",
5905                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
5906                 }
5907
5908 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5909                 if ($line =~ /^.\s*__initcall\s*\(/) {
5910                         WARN("USE_DEVICE_INITCALL",
5911                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5912                 }
5913
5914 # check for various structs that are normally const (ops, kgdb, device_tree)
5915                 my $const_structs = qr{
5916                                 acpi_dock_ops|
5917                                 address_space_operations|
5918                                 backlight_ops|
5919                                 block_device_operations|
5920                                 dentry_operations|
5921                                 dev_pm_ops|
5922                                 dma_map_ops|
5923                                 extent_io_ops|
5924                                 file_lock_operations|
5925                                 file_operations|
5926                                 hv_ops|
5927                                 ide_dma_ops|
5928                                 intel_dvo_dev_ops|
5929                                 item_operations|
5930                                 iwl_ops|
5931                                 kgdb_arch|
5932                                 kgdb_io|
5933                                 kset_uevent_ops|
5934                                 lock_manager_operations|
5935                                 microcode_ops|
5936                                 mtrr_ops|
5937                                 neigh_ops|
5938                                 nlmsvc_binding|
5939                                 of_device_id|
5940                                 pci_raw_ops|
5941                                 pipe_buf_operations|
5942                                 platform_hibernation_ops|
5943                                 platform_suspend_ops|
5944                                 proto_ops|
5945                                 rpc_pipe_ops|
5946                                 seq_operations|
5947                                 snd_ac97_build_ops|
5948                                 soc_pcmcia_socket_ops|
5949                                 stacktrace_ops|
5950                                 sysfs_ops|
5951                                 tty_operations|
5952                                 uart_ops|
5953                                 usb_mon_operations|
5954                                 wd_ops}x;
5955                 if ($line !~ /\bconst\b/ &&
5956                     $line =~ /\bstruct\s+($const_structs)\b/) {
5957                         WARN("CONST_STRUCT",
5958                              "struct $1 should normally be const\n" .
5959                                 $herecurr);
5960                 }
5961
5962 # use of NR_CPUS is usually wrong
5963 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5964                 if ($line =~ /\bNR_CPUS\b/ &&
5965                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5966                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5967                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5968                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5969                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5970                 {
5971                         WARN("NR_CPUS",
5972                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5973                 }
5974
5975 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5976                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5977                         ERROR("DEFINE_ARCH_HAS",
5978                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5979                 }
5980
5981 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5982                 if ($^V && $^V ge 5.10.0 &&
5983                     $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5984                         WARN("LIKELY_MISUSE",
5985                              "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5986                 }
5987
5988 # whine mightly about in_atomic
5989                 if ($line =~ /\bin_atomic\s*\(/) {
5990                         if ($realfile =~ m@^drivers/@) {
5991                                 ERROR("IN_ATOMIC",
5992                                       "do not use in_atomic in drivers\n" . $herecurr);
5993                         } elsif ($realfile !~ m@^kernel/@) {
5994                                 WARN("IN_ATOMIC",
5995                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5996                         }
5997                 }
5998
5999 # whine about ACCESS_ONCE
6000                 if ($^V && $^V ge 5.10.0 &&
6001                     $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
6002                         my $par = $1;
6003                         my $eq = $2;
6004                         my $fun = $3;
6005                         $par =~ s/^\(\s*(.*)\s*\)$/$1/;
6006                         if (defined($eq)) {
6007                                 if (WARN("PREFER_WRITE_ONCE",
6008                                          "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
6009                                     $fix) {
6010                                         $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
6011                                 }
6012                         } else {
6013                                 if (WARN("PREFER_READ_ONCE",
6014                                          "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
6015                                     $fix) {
6016                                         $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
6017                                 }
6018                         }
6019                 }
6020
6021 # check for lockdep_set_novalidate_class
6022                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6023                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
6024                         if ($realfile !~ m@^kernel/lockdep@ &&
6025                             $realfile !~ m@^include/linux/lockdep@ &&
6026                             $realfile !~ m@^drivers/base/core@) {
6027                                 ERROR("LOCKDEP",
6028                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6029                         }
6030                 }
6031
6032                 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6033                     $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6034                         WARN("EXPORTED_WORLD_WRITABLE",
6035                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6036                 }
6037
6038 # Mode permission misuses where it seems decimal should be octal
6039 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6040                 if ($^V && $^V ge 5.10.0 &&
6041                     $line =~ /$mode_perms_search/) {
6042                         foreach my $entry (@mode_permission_funcs) {
6043                                 my $func = $entry->[0];
6044                                 my $arg_pos = $entry->[1];
6045
6046                                 my $skip_args = "";
6047                                 if ($arg_pos > 1) {
6048                                         $arg_pos--;
6049                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6050                                 }
6051                                 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6052                                 if ($line =~ /$test/) {
6053                                         my $val = $1;
6054                                         $val = $6 if ($skip_args ne "");
6055                                         if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6056                                             ($val =~ /^$Octal$/ && length($val) ne 4)) {
6057                                                 ERROR("NON_OCTAL_PERMISSIONS",
6058                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
6059                                         }
6060                                         if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6061                                                 ERROR("EXPORTED_WORLD_WRITABLE",
6062                                                       "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6063                                         }
6064                                         if ($val =~ /\b$mode_perms_string_search\b/) {
6065                                                 my $to = 0;
6066                                                 while ($val =~ /\b($mode_perms_string_search)\b(?:\s*\|\s*)?\s*/g) {
6067                                                         $to |=  $mode_permission_string_types{$1};
6068                                                 }
6069                                                 my $new = sprintf("%04o", $to);
6070                                                 if (WARN("SYMBOLIC_PERMS",
6071                                                          "Symbolic permissions are not preferred. Consider using octal permissions $new.\n" . $herecurr) &&
6072                                                     $fix) {
6073                                                         $fixed[$fixlinenr] =~ s/\Q$val\E/$new/;
6074                                                 }
6075                                         }
6076                                 }
6077                         }
6078                 }
6079
6080 # validate content of MODULE_LICENSE against list from include/linux/module.h
6081                 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6082                         my $extracted_string = get_quoted_string($line, $rawline);
6083                         my $valid_licenses = qr{
6084                                                 GPL|
6085                                                 GPL\ v2|
6086                                                 GPL\ and\ additional\ rights|
6087                                                 Dual\ BSD/GPL|
6088                                                 Dual\ MIT/GPL|
6089                                                 Dual\ MPL/GPL|
6090                                                 Proprietary
6091                                         }x;
6092                         if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6093                                 WARN("MODULE_LICENSE",
6094                                      "unknown module license " . $extracted_string . "\n" . $herecurr);
6095                         }
6096                 }
6097         }
6098
6099         # If we have no input at all, then there is nothing to report on
6100         # so just keep quiet.
6101         if ($#rawlines == -1) {
6102                 exit(0);
6103         }
6104
6105         # In mailback mode only produce a report in the negative, for
6106         # things that appear to be patches.
6107         if ($mailback && ($clean == 1 || !$is_patch)) {
6108                 exit(0);
6109         }
6110
6111         # This is not a patch, and we are are in 'no-patch' mode so
6112         # just keep quiet.
6113         if (!$chk_patch && !$is_patch) {
6114                 exit(0);
6115         }
6116
6117         if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6118                 ERROR("NOT_UNIFIED_DIFF",
6119                       "Does not appear to be a unified-diff format patch\n");
6120         }
6121         if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6122                 ERROR("MISSING_SIGN_OFF",
6123                       "Missing Signed-off-by: line(s)\n");
6124         }
6125
6126         print report_dump();
6127         if ($summary && !($clean == 1 && $quiet == 1)) {
6128                 print "$filename " if ($summary_file);
6129                 print "total: $cnt_error errors, $cnt_warn warnings, " .
6130                         (($check)? "$cnt_chk checks, " : "") .
6131                         "$cnt_lines lines checked\n";
6132         }
6133
6134         if ($quiet == 0) {
6135                 # If there were any defects found and not already fixing them
6136                 if (!$clean and !$fix) {
6137                         print << "EOM"
6138
6139 NOTE: For some of the reported defects, checkpatch may be able to
6140       mechanically convert to the typical style using --fix or --fix-inplace.
6141 EOM
6142                 }
6143                 # If there were whitespace errors which cleanpatch can fix
6144                 # then suggest that.
6145                 if ($rpt_cleaners) {
6146                         $rpt_cleaners = 0;
6147                         print << "EOM"
6148
6149 NOTE: Whitespace errors detected.
6150       You may wish to use scripts/cleanpatch or scripts/cleanfile
6151 EOM
6152                 }
6153         }
6154
6155         if ($clean == 0 && $fix &&
6156             ("@rawlines" ne "@fixed" ||
6157              $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6158                 my $newfile = $filename;
6159                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6160                 my $linecount = 0;
6161                 my $f;
6162
6163                 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6164
6165                 open($f, '>', $newfile)
6166                     or die "$P: Can't open $newfile for write\n";
6167                 foreach my $fixed_line (@fixed) {
6168                         $linecount++;
6169                         if ($file) {
6170                                 if ($linecount > 3) {
6171                                         $fixed_line =~ s/^\+//;
6172                                         print $f $fixed_line . "\n";
6173                                 }
6174                         } else {
6175                                 print $f $fixed_line . "\n";
6176                         }
6177                 }
6178                 close($f);
6179
6180                 if (!$quiet) {
6181                         print << "EOM";
6182
6183 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6184
6185 Do _NOT_ trust the results written to this file.
6186 Do _NOT_ submit these changes without inspecting them for correctness.
6187
6188 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6189 No warranties, expressed or implied...
6190 EOM
6191                 }
6192         }
6193
6194         if ($quiet == 0) {
6195                 print "\n";
6196                 if ($clean == 1) {
6197                         print "$vname has no obvious style problems and is ready for submission.\n";
6198                 } else {
6199                         print "$vname has style problems, please review.\n";
6200                 }
6201         }
6202         return $clean;
6203 }