scripts/checkpatch.pl

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