scripts/checkpatch.pl

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