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