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