scripts/checkpatch.pl

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