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