scripts/checkpatch.pl

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