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