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