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