tests/checkpatch.pl

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