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