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