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