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