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