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