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