scripts/checkpatch.pl

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