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