scripts/checkpatch.pl

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