scripts/checkpatch.pl

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