scripts/checkpatch.pl

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