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