scripts/checkpatch.pl

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