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 #
2879 # There are 3 different line length message types:
2880 # LONG_LINE_COMMENT     a comment starts before but extends beyond $max_line_length
2881 # LONG_LINE_STRING      a string starts before but extends beyond $max_line_length
2882 # LONG_LINE             all other lines longer than $max_line_length
2883 #
2884 # if LONG_LINE is ignored, the other 2 types are also ignored
2885 #
2886
2887                 if ($line =~ /^\+/ && $length > $max_line_length) {
2888                         my $msg_type = "LONG_LINE";
2889
2890                         # Check the allowed long line types first
2891
2892                         # logging functions that end in a string that starts
2893                         # before $max_line_length
2894                         if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2895                             length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2896                                 $msg_type = "";
2897
2898                         # lines with only strings (w/ possible termination)
2899                         # #defines with only strings
2900                         } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2901                                  $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2902                                 $msg_type = "";
2903
2904                         # More special cases
2905                         } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
2906                                  $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
2907                                 $msg_type = "";
2908
2909                         # Otherwise set the alternate message types
2910
2911                         # a comment starts before $max_line_length
2912                         } elsif ($line =~ /($;[\s$;]*)$/ &&
2913                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2914                                 $msg_type = "LONG_LINE_COMMENT"
2915
2916                         # a quoted string starts before $max_line_length
2917                         } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2918                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2919                                 $msg_type = "LONG_LINE_STRING"
2920                         }
2921
2922                         if ($msg_type ne "" &&
2923                             (show_type("LONG_LINE") || show_type($msg_type))) {
2924                                 WARN($msg_type,
2925                                      "line over $max_line_length characters\n" . $herecurr);
2926                         }
2927                 }
2928
2929 # check for adding lines without a newline.
2930                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2931                         WARN("MISSING_EOF_NEWLINE",
2932                              "adding a line without newline at end of file\n" . $herecurr);
2933                 }
2934
2935 # Blackfin: use hi/lo macros
2936                 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2937                         if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2938                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2939                                 ERROR("LO_MACRO",
2940                                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2941                         }
2942                         if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2943                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2944                                 ERROR("HI_MACRO",
2945                                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2946                         }
2947                 }
2948
2949 # check we are in a valid source file C or perl if not then ignore this hunk
2950                 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2951
2952 # at the beginning of a line any tabs must come first and anything
2953 # more than 8 must use tabs.
2954                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2955                     $rawline =~ /^\+\s*        \s*/) {
2956                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2957                         $rpt_cleaners = 1;
2958                         if (ERROR("CODE_INDENT",
2959                                   "code indent should use tabs where possible\n" . $herevet) &&
2960                             $fix) {
2961                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2962                         }
2963                 }
2964
2965 # check for space before tabs.
2966                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2967                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2968                         if (WARN("SPACE_BEFORE_TAB",
2969                                 "please, no space before tabs\n" . $herevet) &&
2970                             $fix) {
2971                                 while ($fixed[$fixlinenr] =~
2972                                            s/(^\+.*) {8,8}\t/$1\t\t/) {}
2973                                 while ($fixed[$fixlinenr] =~
2974                                            s/(^\+.*) +\t/$1\t/) {}
2975                         }
2976                 }
2977
2978 # check for && or || at the start of a line
2979                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2980                         CHK("LOGICAL_CONTINUATIONS",
2981                             "Logical continuations should be on the previous line\n" . $hereprev);
2982                 }
2983
2984 # check indentation starts on a tab stop
2985                 if ($^V && $^V ge 5.10.0 &&
2986                     $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2987                         my $indent = length($1);
2988                         if ($indent % 8) {
2989                                 if (WARN("TABSTOP",
2990                                          "Statements should start on a tabstop\n" . $herecurr) &&
2991                                     $fix) {
2992                                         $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2993                                 }
2994                         }
2995                 }
2996
2997 # check multi-line statement indentation matches previous line
2998                 if ($^V && $^V ge 5.10.0 &&
2999                     $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3000                         $prevline =~ /^\+(\t*)(.*)$/;
3001                         my $oldindent = $1;
3002                         my $rest = $2;
3003
3004                         my $pos = pos_last_openparen($rest);
3005                         if ($pos >= 0) {
3006                                 $line =~ /^(\+| )([ \t]*)/;
3007                                 my $newindent = $2;
3008
3009                                 my $goodtabindent = $oldindent .
3010                                         "\t" x ($pos / 8) .
3011                                         " "  x ($pos % 8);
3012                                 my $goodspaceindent = $oldindent . " "  x $pos;
3013
3014                                 if ($newindent ne $goodtabindent &&
3015                                     $newindent ne $goodspaceindent) {
3016
3017                                         if (CHK("PARENTHESIS_ALIGNMENT",
3018                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
3019                                             $fix && $line =~ /^\+/) {
3020                                                 $fixed[$fixlinenr] =~
3021                                                     s/^\+[ \t]*/\+$goodtabindent/;
3022                                         }
3023                                 }
3024                         }
3025                 }
3026
3027 # check for space after cast like "(int) foo" or "(struct foo) bar"
3028 # avoid checking a few false positives:
3029 #   "sizeof(<type>)" or "__alignof__(<type>)"
3030 #   function pointer declarations like "(*foo)(int) = bar;"
3031 #   structure definitions like "(struct foo) { 0 };"
3032 #   multiline macros that define functions
3033 #   known attributes or the __attribute__ keyword
3034                 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3035                     (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3036                         if (CHK("SPACING",
3037                                 "No space is necessary after a cast\n" . $herecurr) &&
3038                             $fix) {
3039                                 $fixed[$fixlinenr] =~
3040                                     s/(\(\s*$Type\s*\))[ \t]+/$1/;
3041                         }
3042                 }
3043
3044 # Block comment styles
3045 # Networking with an initial /*
3046                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3047                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3048                     $rawline =~ /^\+[ \t]*\*/ &&
3049                     $realline > 2) {
3050                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3051                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3052                 }
3053
3054 # Block comments use * on subsequent lines
3055                 if ($prevline =~ /$;[ \t]*$/ &&                 #ends in comment
3056                     $prevrawline =~ /^\+.*?\/\*/ &&             #starting /*
3057                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
3058                     $rawline =~ /^\+/ &&                        #line is new
3059                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
3060                         WARN("BLOCK_COMMENT_STYLE",
3061                              "Block comments use * on subsequent lines\n" . $hereprev);
3062                 }
3063
3064 # Block comments use */ on trailing lines
3065                 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
3066                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
3067                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
3068                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
3069                         WARN("BLOCK_COMMENT_STYLE",
3070                              "Block comments use a trailing */ on a separate line\n" . $herecurr);
3071                 }
3072
3073 # Block comment * alignment
3074                 if ($prevline =~ /$;[ \t]*$/ &&                 #ends in comment
3075                     $line =~ /^\+[ \t]*$;/ &&                   #leading comment
3076                     $rawline =~ /^\+[ \t]*\*/ &&                #leading *
3077                     (($prevrawline =~ /^\+.*?\/\*/ &&           #leading /*
3078                       $prevrawline !~ /\*\/[ \t]*$/) ||         #no trailing */
3079                      $prevrawline =~ /^\+[ \t]*\*/)) {          #leading *
3080                         my $oldindent;
3081                         $prevrawline =~ m@^\+([ \t]*/?)\*@;
3082                         if (defined($1)) {
3083                                 $oldindent = expand_tabs($1);
3084                         } else {
3085                                 $prevrawline =~ m@^\+(.*/?)\*@;
3086                                 $oldindent = expand_tabs($1);
3087                         }
3088                         $rawline =~ m@^\+([ \t]*)\*@;
3089                         my $newindent = $1;
3090                         $newindent = expand_tabs($newindent);
3091                         if (length($oldindent) ne length($newindent)) {
3092                                 WARN("BLOCK_COMMENT_STYLE",
3093                                      "Block comments should align the * on each line\n" . $hereprev);
3094                         }
3095                 }
3096
3097 # check for missing blank lines after struct/union declarations
3098 # with exceptions for various attributes and macros
3099                 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3100                     $line =~ /^\+/ &&
3101                     !($line =~ /^\+\s*$/ ||
3102                       $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3103                       $line =~ /^\+\s*MODULE_/i ||
3104                       $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3105                       $line =~ /^\+[a-z_]*init/ ||
3106                       $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3107                       $line =~ /^\+\s*DECLARE/ ||
3108                       $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3109                       $line =~ /^\+\s*__setup/)) {
3110                         if (CHK("LINE_SPACING",
3111                                 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3112                             $fix) {
3113                                 fix_insert_line($fixlinenr, "\+");
3114                         }
3115                 }
3116
3117 # check for multiple consecutive blank lines
3118                 if ($prevline =~ /^[\+ ]\s*$/ &&
3119                     $line =~ /^\+\s*$/ &&
3120                     $last_blank_line != ($linenr - 1)) {
3121                         if (CHK("LINE_SPACING",
3122                                 "Please don't use multiple blank lines\n" . $hereprev) &&
3123                             $fix) {
3124                                 fix_delete_line($fixlinenr, $rawline);
3125                         }
3126
3127                         $last_blank_line = $linenr;
3128                 }
3129
3130 # check for missing blank lines after declarations
3131                 if ($sline =~ /^\+\s+\S/ &&                     #Not at char 1
3132                         # actual declarations
3133                     ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3134                         # function pointer declarations
3135                      $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3136                         # foo bar; where foo is some local typedef or #define
3137                      $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3138                         # known declaration macros
3139                      $prevline =~ /^\+\s+$declaration_macros/) &&
3140                         # for "else if" which can look like "$Ident $Ident"
3141                     !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3142                         # other possible extensions of declaration lines
3143                       $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3144                         # not starting a section or a macro "\" extended line
3145                       $prevline =~ /(?:\{\s*|\\)$/) &&
3146                         # looks like a declaration
3147                     !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3148                         # function pointer declarations
3149                       $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3150                         # foo bar; where foo is some local typedef or #define
3151                       $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3152                         # known declaration macros
3153                       $sline =~ /^\+\s+$declaration_macros/ ||
3154                         # start of struct or union or enum
3155                       $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3156                         # start or end of block or continuation of declaration
3157                       $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3158                         # bitfield continuation
3159                       $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3160                         # other possible extensions of declaration lines
3161                       $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3162                         # indentation of previous and current line are the same
3163                     (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3164                         if (WARN("LINE_SPACING",
3165                                  "Missing a blank line after declarations\n" . $hereprev) &&
3166                             $fix) {
3167                                 fix_insert_line($fixlinenr, "\+");
3168                         }
3169                 }
3170
3171 # check for spaces at the beginning of a line.
3172 # Exceptions:
3173 #  1) within comments
3174 #  2) indented preprocessor commands
3175 #  3) hanging labels
3176                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
3177                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3178                         if (WARN("LEADING_SPACE",
3179                                  "please, no spaces at the start of a line\n" . $herevet) &&
3180                             $fix) {
3181                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3182                         }
3183                 }
3184
3185 # check we are in a valid C source file if not then ignore this hunk
3186                 next if ($realfile !~ /\.(h|c)$/);
3187
3188 # check for unusual line ending [ or (
3189                 if ($line =~ /^\+.*([\[\(])\s*$/) {
3190                         CHK("OPEN_ENDED_LINE",
3191                             "Lines should not end with a '$1'\n" . $herecurr);
3192                 }
3193
3194 # check if this appears to be the start function declaration, save the name
3195                 if ($sline =~ /^\+\{\s*$/ &&
3196                     $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3197                         $context_function = $1;
3198                 }
3199
3200 # check if this appears to be the end of function declaration
3201                 if ($sline =~ /^\+\}\s*$/) {
3202                         undef $context_function;
3203                 }
3204
3205 # check indentation of any line with a bare else
3206 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3207 # if the previous line is a break or return and is indented 1 tab more...
3208                 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3209                         my $tabs = length($1) + 1;
3210                         if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3211                             ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3212                              defined $lines[$linenr] &&
3213                              $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3214                                 WARN("UNNECESSARY_ELSE",
3215                                      "else is not generally useful after a break or return\n" . $hereprev);
3216                         }
3217                 }
3218
3219 # check indentation of a line with a break;
3220 # if the previous line is a goto or return and is indented the same # of tabs
3221                 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3222                         my $tabs = $1;
3223                         if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3224                                 WARN("UNNECESSARY_BREAK",
3225                                      "break is not useful after a goto or return\n" . $hereprev);
3226                         }
3227                 }
3228
3229 # check for RCS/CVS revision markers
3230                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3231                         WARN("CVS_KEYWORD",
3232                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3233                 }
3234
3235 # Blackfin: don't use __builtin_bfin_[cs]sync
3236                 if ($line =~ /__builtin_bfin_csync/) {
3237                         my $herevet = "$here\n" . cat_vet($line) . "\n";
3238                         ERROR("CSYNC",
3239                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3240                 }
3241                 if ($line =~ /__builtin_bfin_ssync/) {
3242                         my $herevet = "$here\n" . cat_vet($line) . "\n";
3243                         ERROR("SSYNC",
3244                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3245                 }
3246
3247 # check for old HOTPLUG __dev<foo> section markings
3248                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3249                         WARN("HOTPLUG_SECTION",
3250                              "Using $1 is unnecessary\n" . $herecurr);
3251                 }
3252
3253 # Check for potential 'bare' types
3254                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3255                     $realline_next);
3256 #print "LINE<$line>\n";
3257                 if ($linenr > $suppress_statement &&
3258                     $realcnt && $sline =~ /.\s*\S/) {
3259                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3260                                 ctx_statement_block($linenr, $realcnt, 0);
3261                         $stat =~ s/\n./\n /g;
3262                         $cond =~ s/\n./\n /g;
3263
3264 #print "linenr<$linenr> <$stat>\n";
3265                         # If this statement has no statement boundaries within
3266                         # it there is no point in retrying a statement scan
3267                         # until we hit end of it.
3268                         my $frag = $stat; $frag =~ s/;+\s*$//;
3269                         if ($frag !~ /(?:{|;)/) {
3270 #print "skip<$line_nr_next>\n";
3271                                 $suppress_statement = $line_nr_next;
3272                         }
3273
3274                         # Find the real next line.
3275                         $realline_next = $line_nr_next;
3276                         if (defined $realline_next &&
3277                             (!defined $lines[$realline_next - 1] ||
3278                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3279                                 $realline_next++;
3280                         }
3281
3282                         my $s = $stat;
3283                         $s =~ s/{.*$//s;
3284
3285                         # Ignore goto labels.
3286                         if ($s =~ /$Ident:\*$/s) {
3287
3288                         # Ignore functions being called
3289                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3290
3291                         } elsif ($s =~ /^.\s*else\b/s) {
3292
3293                         # declarations always start with types
3294                         } 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) {
3295                                 my $type = $1;
3296                                 $type =~ s/\s+/ /g;
3297                                 possible($type, "A:" . $s);
3298
3299                         # definitions in global scope can only start with types
3300                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3301                                 possible($1, "B:" . $s);
3302                         }
3303
3304                         # any (foo ... *) is a pointer cast, and foo is a type
3305                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3306                                 possible($1, "C:" . $s);
3307                         }
3308
3309                         # Check for any sort of function declaration.
3310                         # int foo(something bar, other baz);
3311                         # void (*store_gdt)(x86_descr_ptr *);
3312                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3313                                 my ($name_len) = length($1);
3314
3315                                 my $ctx = $s;
3316                                 substr($ctx, 0, $name_len + 1, '');
3317                                 $ctx =~ s/\)[^\)]*$//;
3318
3319                                 for my $arg (split(/\s*,\s*/, $ctx)) {
3320                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3321
3322                                                 possible($1, "D:" . $s);
3323                                         }
3324                                 }
3325                         }
3326
3327                 }
3328
3329 #
3330 # Checks which may be anchored in the context.
3331 #
3332
3333 # Check for switch () and associated case and default
3334 # statements should be at the same indent.
3335                 if ($line=~/\bswitch\s*\(.*\)/) {
3336                         my $err = '';
3337                         my $sep = '';
3338                         my @ctx = ctx_block_outer($linenr, $realcnt);
3339                         shift(@ctx);
3340                         for my $ctx (@ctx) {
3341                                 my ($clen, $cindent) = line_stats($ctx);
3342                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3343                                                         $indent != $cindent) {
3344                                         $err .= "$sep$ctx\n";
3345                                         $sep = '';
3346                                 } else {
3347                                         $sep = "[...]\n";
3348                                 }
3349                         }
3350                         if ($err ne '') {
3351                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
3352                                       "switch and case should be at the same indent\n$hereline$err");
3353                         }
3354                 }
3355
3356 # if/while/etc brace do not go on next line, unless defining a do while loop,
3357 # or if that brace on the next line is for something else
3358                 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3359                         my $pre_ctx = "$1$2";
3360
3361                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3362
3363                         if ($line =~ /^\+\t{6,}/) {
3364                                 WARN("DEEP_INDENTATION",
3365                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
3366                         }
3367
3368                         my $ctx_cnt = $realcnt - $#ctx - 1;
3369                         my $ctx = join("\n", @ctx);
3370
3371                         my $ctx_ln = $linenr;
3372                         my $ctx_skip = $realcnt;
3373
3374                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3375                                         defined $lines[$ctx_ln - 1] &&
3376                                         $lines[$ctx_ln - 1] =~ /^-/)) {
3377                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3378                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3379                                 $ctx_ln++;
3380                         }
3381
3382                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3383                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3384
3385                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3386                                 ERROR("OPEN_BRACE",
3387                                       "that open brace { should be on the previous line\n" .
3388                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3389                         }
3390                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3391                             $ctx =~ /\)\s*\;\s*$/ &&
3392                             defined $lines[$ctx_ln - 1])
3393                         {
3394                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3395                                 if ($nindent > $indent) {
3396                                         WARN("TRAILING_SEMICOLON",
3397                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
3398                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3399                                 }
3400                         }
3401                 }
3402
3403 # Check relative indent for conditionals and blocks.
3404                 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3405                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3406                                 ctx_statement_block($linenr, $realcnt, 0)
3407                                         if (!defined $stat);
3408                         my ($s, $c) = ($stat, $cond);
3409
3410                         substr($s, 0, length($c), '');
3411
3412                         # remove inline comments
3413                         $s =~ s/$;/ /g;
3414                         $c =~ s/$;/ /g;
3415
3416                         # Find out how long the conditional actually is.
3417                         my @newlines = ($c =~ /\n/gs);
3418                         my $cond_lines = 1 + $#newlines;
3419
3420                         # Make sure we remove the line prefixes as we have
3421                         # none on the first line, and are going to readd them
3422                         # where necessary.
3423                         $s =~ s/\n./\n/gs;
3424                         while ($s =~ /\n\s+\\\n/) {
3425                                 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3426                         }
3427
3428                         # We want to check the first line inside the block
3429                         # starting at the end of the conditional, so remove:
3430                         #  1) any blank line termination
3431                         #  2) any opening brace { on end of the line
3432                         #  3) any do (...) {
3433                         my $continuation = 0;
3434                         my $check = 0;
3435                         $s =~ s/^.*\bdo\b//;
3436                         $s =~ s/^\s*{//;
3437                         if ($s =~ s/^\s*\\//) {
3438                                 $continuation = 1;
3439                         }
3440                         if ($s =~ s/^\s*?\n//) {
3441                                 $check = 1;
3442                                 $cond_lines++;
3443                         }
3444
3445                         # Also ignore a loop construct at the end of a
3446                         # preprocessor statement.
3447                         if (($prevline =~ /^.\s*#\s*define\s/ ||
3448                             $prevline =~ /\\\s*$/) && $continuation == 0) {
3449                                 $check = 0;
3450                         }
3451
3452                         my $cond_ptr = -1;
3453                         $continuation = 0;
3454                         while ($cond_ptr != $cond_lines) {
3455                                 $cond_ptr = $cond_lines;
3456
3457                                 # If we see an #else/#elif then the code
3458                                 # is not linear.
3459                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3460                                         $check = 0;
3461                                 }
3462
3463                                 # Ignore:
3464                                 #  1) blank lines, they should be at 0,
3465                                 #  2) preprocessor lines, and
3466                                 #  3) labels.
3467                                 if ($continuation ||
3468                                     $s =~ /^\s*?\n/ ||
3469                                     $s =~ /^\s*#\s*?/ ||
3470                                     $s =~ /^\s*$Ident\s*:/) {
3471                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3472                                         if ($s =~ s/^.*?\n//) {
3473                                                 $cond_lines++;
3474                                         }
3475                                 }
3476                         }
3477
3478                         my (undef, $sindent) = line_stats("+" . $s);
3479                         my $stat_real = raw_line($linenr, $cond_lines);
3480
3481                         # Check if either of these lines are modified, else
3482                         # this is not this patch's fault.
3483                         if (!defined($stat_real) ||
3484                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3485                                 $check = 0;
3486                         }
3487                         if (defined($stat_real) && $cond_lines > 1) {
3488                                 $stat_real = "[...]\n$stat_real";
3489                         }
3490
3491                         #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";
3492
3493                         if ($check && $s ne '' &&
3494                             (($sindent % 8) != 0 ||
3495                              ($sindent < $indent) ||
3496                              ($sindent == $indent &&
3497                               ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3498                              ($sindent > $indent + 8))) {
3499                                 WARN("SUSPECT_CODE_INDENT",
3500                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3501                         }
3502                 }
3503
3504                 # Track the 'values' across context and added lines.
3505                 my $opline = $line; $opline =~ s/^./ /;
3506                 my ($curr_values, $curr_vars) =
3507                                 annotate_values($opline . "\n", $prev_values);
3508                 $curr_values = $prev_values . $curr_values;
3509                 if ($dbg_values) {
3510                         my $outline = $opline; $outline =~ s/\t/ /g;
3511                         print "$linenr > .$outline\n";
3512                         print "$linenr > $curr_values\n";
3513                         print "$linenr >  $curr_vars\n";
3514                 }
3515                 $prev_values = substr($curr_values, -1);
3516
3517 #ignore lines not being added
3518                 next if ($line =~ /^[^\+]/);
3519
3520 # check for dereferences that span multiple lines
3521                 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3522                     $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3523                         $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3524                         my $ref = $1;
3525                         $line =~ /^.\s*($Lval)/;
3526                         $ref .= $1;
3527                         $ref =~ s/\s//g;
3528                         WARN("MULTILINE_DEREFERENCE",
3529                              "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3530                 }
3531
3532 # check for declarations of signed or unsigned without int
3533                 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3534                         my $type = $1;
3535                         my $var = $2;
3536                         $var = "" if (!defined $var);
3537                         if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3538                                 my $sign = $1;
3539                                 my $pointer = $2;
3540
3541                                 $pointer = "" if (!defined $pointer);
3542
3543                                 if (WARN("UNSPECIFIED_INT",
3544                                          "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3545                                     $fix) {
3546                                         my $decl = trim($sign) . " int ";
3547                                         my $comp_pointer = $pointer;
3548                                         $comp_pointer =~ s/\s//g;
3549                                         $decl .= $comp_pointer;
3550                                         $decl = rtrim($decl) if ($var eq "");
3551                                         $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3552                                 }
3553                         }
3554                 }
3555
3556 # TEST: allow direct testing of the type matcher.
3557                 if ($dbg_type) {
3558                         if ($line =~ /^.\s*$Declare\s*$/) {
3559                                 ERROR("TEST_TYPE",
3560                                       "TEST: is type\n" . $herecurr);
3561                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3562                                 ERROR("TEST_NOT_TYPE",
3563                                       "TEST: is not type ($1 is)\n". $herecurr);
3564                         }
3565                         next;
3566                 }
3567 # TEST: allow direct testing of the attribute matcher.
3568                 if ($dbg_attr) {
3569                         if ($line =~ /^.\s*$Modifier\s*$/) {
3570                                 ERROR("TEST_ATTR",
3571                                       "TEST: is attr\n" . $herecurr);
3572                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3573                                 ERROR("TEST_NOT_ATTR",
3574                                       "TEST: is not attr ($1 is)\n". $herecurr);
3575                         }
3576                         next;
3577                 }
3578
3579 # check for initialisation to aggregates open brace on the next line
3580                 if ($line =~ /^.\s*{/ &&
3581                     $prevline =~ /(?:^|[^=])=\s*$/) {
3582                         if (ERROR("OPEN_BRACE",
3583                                   "that open brace { should be on the previous line\n" . $hereprev) &&
3584                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3585                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3586                                 fix_delete_line($fixlinenr, $rawline);
3587                                 my $fixedline = $prevrawline;
3588                                 $fixedline =~ s/\s*=\s*$/ = {/;
3589                                 fix_insert_line($fixlinenr, $fixedline);
3590                                 $fixedline = $line;
3591                                 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3592                                 fix_insert_line($fixlinenr, $fixedline);
3593                         }
3594                 }
3595
3596 #
3597 # Checks which are anchored on the added line.
3598 #
3599
3600 # check for malformed paths in #include statements (uses RAW line)
3601                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3602                         my $path = $1;
3603                         if ($path =~ m{//}) {
3604                                 ERROR("MALFORMED_INCLUDE",
3605                                       "malformed #include filename\n" . $herecurr);
3606                         }
3607                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3608                                 ERROR("UAPI_INCLUDE",
3609                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3610                         }
3611                 }
3612
3613 # no C99 // comments
3614                 if ($line =~ m{//}) {
3615                         if (ERROR("C99_COMMENTS",
3616                                   "do not use C99 // comments\n" . $herecurr) &&
3617                             $fix) {
3618                                 my $line = $fixed[$fixlinenr];
3619                                 if ($line =~ /\/\/(.*)$/) {
3620                                         my $comment = trim($1);
3621                                         $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3622                                 }
3623                         }
3624                 }
3625                 # Remove C99 comments.
3626                 $line =~ s@//.*@@;
3627                 $opline =~ s@//.*@@;
3628
3629 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3630 # the whole statement.
3631 #print "APW <$lines[$realline_next - 1]>\n";
3632                 if (defined $realline_next &&
3633                     exists $lines[$realline_next - 1] &&
3634                     !defined $suppress_export{$realline_next} &&
3635                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3636                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3637                         # Handle definitions which produce identifiers with
3638                         # a prefix:
3639                         #   XXX(foo);
3640                         #   EXPORT_SYMBOL(something_foo);
3641                         my $name = $1;
3642                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3643                             $name =~ /^${Ident}_$2/) {
3644 #print "FOO C name<$name>\n";
3645                                 $suppress_export{$realline_next} = 1;
3646
3647                         } elsif ($stat !~ /(?:
3648                                 \n.}\s*$|
3649                                 ^.DEFINE_$Ident\(\Q$name\E\)|
3650                                 ^.DECLARE_$Ident\(\Q$name\E\)|
3651                                 ^.LIST_HEAD\(\Q$name\E\)|
3652                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3653                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3654                             )/x) {
3655 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3656                                 $suppress_export{$realline_next} = 2;
3657                         } else {
3658                                 $suppress_export{$realline_next} = 1;
3659                         }
3660                 }
3661                 if (!defined $suppress_export{$linenr} &&
3662                     $prevline =~ /^.\s*$/ &&
3663                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3664                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3665 #print "FOO B <$lines[$linenr - 1]>\n";
3666                         $suppress_export{$linenr} = 2;
3667                 }
3668                 if (defined $suppress_export{$linenr} &&
3669                     $suppress_export{$linenr} == 2) {
3670                         WARN("EXPORT_SYMBOL",
3671                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3672                 }
3673
3674 # check for global initialisers.
3675                 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3676                         if (ERROR("GLOBAL_INITIALISERS",
3677                                   "do not initialise globals to $1\n" . $herecurr) &&
3678                             $fix) {
3679                                 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3680                         }
3681                 }
3682 # check for static initialisers.
3683                 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3684                         if (ERROR("INITIALISED_STATIC",
3685                                   "do not initialise statics to $1\n" .
3686                                       $herecurr) &&
3687                             $fix) {
3688                                 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3689                         }
3690                 }
3691
3692 # check for misordered declarations of char/short/int/long with signed/unsigned
3693                 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3694                         my $tmp = trim($1);
3695                         WARN("MISORDERED_TYPE",
3696                              "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3697                 }
3698
3699 # check for static const char * arrays.
3700                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3701                         WARN("STATIC_CONST_CHAR_ARRAY",
3702                              "static const char * array should probably be static const char * const\n" .
3703                                 $herecurr);
3704                }
3705
3706 # check for static char foo[] = "bar" declarations.
3707                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3708                         WARN("STATIC_CONST_CHAR_ARRAY",
3709                              "static char array declaration should probably be static const char\n" .
3710                                 $herecurr);
3711                }
3712
3713 # check for const <foo> const where <foo> is not a pointer or array type
3714                 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3715                         my $found = $1;
3716                         if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3717                                 WARN("CONST_CONST",
3718                                      "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3719                         } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3720                                 WARN("CONST_CONST",
3721                                      "'const $found const' should probably be 'const $found'\n" . $herecurr);
3722                         }
3723                 }
3724
3725 # check for non-global char *foo[] = {"bar", ...} declarations.
3726                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3727                         WARN("STATIC_CONST_CHAR_ARRAY",
3728                              "char * array declaration might be better as static const\n" .
3729                                 $herecurr);
3730                }
3731
3732 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3733                 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3734                         my $array = $1;
3735                         if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3736                                 my $array_div = $1;
3737                                 if (WARN("ARRAY_SIZE",
3738                                          "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3739                                     $fix) {
3740                                         $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3741                                 }
3742                         }
3743                 }
3744
3745 # check for function declarations without arguments like "int foo()"
3746                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3747                         if (ERROR("FUNCTION_WITHOUT_ARGS",
3748                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3749                             $fix) {
3750                                 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3751                         }
3752                 }
3753
3754 # check for new typedefs, only function parameters and sparse annotations
3755 # make sense.
3756                 if ($line =~ /\btypedef\s/ &&
3757                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3758                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3759                     $line !~ /\b$typeTypedefs\b/ &&
3760                     $line !~ /\b__bitwise\b/) {
3761                         WARN("NEW_TYPEDEFS",
3762                              "do not add new typedefs\n" . $herecurr);
3763                 }
3764
3765 # * goes on variable not on type
3766                 # (char*[ const])
3767                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3768                         #print "AA<$1>\n";
3769                         my ($ident, $from, $to) = ($1, $2, $2);
3770
3771                         # Should start with a space.
3772                         $to =~ s/^(\S)/ $1/;
3773                         # Should not end with a space.
3774                         $to =~ s/\s+$//;
3775                         # '*'s should not have spaces between.
3776                         while ($to =~ s/\*\s+\*/\*\*/) {
3777                         }
3778
3779 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
3780                         if ($from ne $to) {
3781                                 if (ERROR("POINTER_LOCATION",
3782                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3783                                     $fix) {
3784                                         my $sub_from = $ident;
3785                                         my $sub_to = $ident;
3786                                         $sub_to =~ s/\Q$from\E/$to/;
3787                                         $fixed[$fixlinenr] =~
3788                                             s@\Q$sub_from\E@$sub_to@;
3789                                 }
3790                         }
3791                 }
3792                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3793                         #print "BB<$1>\n";
3794                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3795
3796                         # Should start with a space.
3797                         $to =~ s/^(\S)/ $1/;
3798                         # Should not end with a space.
3799                         $to =~ s/\s+$//;
3800                         # '*'s should not have spaces between.
3801                         while ($to =~ s/\*\s+\*/\*\*/) {
3802                         }
3803                         # Modifiers should have spaces.
3804                         $to =~ s/(\b$Modifier$)/$1 /;
3805
3806 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
3807                         if ($from ne $to && $ident !~ /^$Modifier$/) {
3808                                 if (ERROR("POINTER_LOCATION",
3809                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3810                                     $fix) {
3811
3812                                         my $sub_from = $match;
3813                                         my $sub_to = $match;
3814                                         $sub_to =~ s/\Q$from\E/$to/;
3815                                         $fixed[$fixlinenr] =~
3816                                             s@\Q$sub_from\E@$sub_to@;
3817                                 }
3818                         }
3819                 }
3820
3821 # avoid BUG() or BUG_ON()
3822                 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3823                         my $msg_level = \&WARN;
3824                         $msg_level = \&CHK if ($file);
3825                         &{$msg_level}("AVOID_BUG",
3826                                       "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3827                 }
3828
3829 # avoid LINUX_VERSION_CODE
3830                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3831                         WARN("LINUX_VERSION_CODE",
3832                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3833                 }
3834
3835 # check for uses of printk_ratelimit
3836                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3837                         WARN("PRINTK_RATELIMITED",
3838                              "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3839                 }
3840
3841 # printk should use KERN_* levels
3842                 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
3843                         WARN("PRINTK_WITHOUT_KERN_LEVEL",
3844                              "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
3845                 }
3846
3847                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3848                         my $orig = $1;
3849                         my $level = lc($orig);
3850                         $level = "warn" if ($level eq "warning");
3851                         my $level2 = $level;
3852                         $level2 = "dbg" if ($level eq "debug");
3853                         WARN("PREFER_PR_LEVEL",
3854                              "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3855                 }
3856
3857                 if ($line =~ /\bpr_warning\s*\(/) {
3858                         if (WARN("PREFER_PR_LEVEL",
3859                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3860                             $fix) {
3861                                 $fixed[$fixlinenr] =~
3862                                     s/\bpr_warning\b/pr_warn/;
3863                         }
3864                 }
3865
3866                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3867                         my $orig = $1;
3868                         my $level = lc($orig);
3869                         $level = "warn" if ($level eq "warning");
3870                         $level = "dbg" if ($level eq "debug");
3871                         WARN("PREFER_DEV_LEVEL",
3872                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3873                 }
3874
3875 # ENOSYS means "bad syscall nr" and nothing else.  This will have a small
3876 # number of false positives, but assembly files are not checked, so at
3877 # least the arch entry code will not trigger this warning.
3878                 if ($line =~ /\bENOSYS\b/) {
3879                         WARN("ENOSYS",
3880                              "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3881                 }
3882
3883 # function brace can't be on same line, except for #defines of do while,
3884 # or if closed on same line
3885                 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3886                     !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3887                         if (ERROR("OPEN_BRACE",
3888                                   "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3889                             $fix) {
3890                                 fix_delete_line($fixlinenr, $rawline);
3891                                 my $fixed_line = $rawline;
3892                                 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3893                                 my $line1 = $1;
3894                                 my $line2 = $2;
3895                                 fix_insert_line($fixlinenr, ltrim($line1));
3896                                 fix_insert_line($fixlinenr, "\+{");
3897                                 if ($line2 !~ /^\s*$/) {
3898                                         fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3899                                 }
3900                         }
3901                 }
3902
3903 # open braces for enum, union and struct go on the same line.
3904                 if ($line =~ /^.\s*{/ &&
3905                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3906                         if (ERROR("OPEN_BRACE",
3907                                   "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3908                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3909                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3910                                 fix_delete_line($fixlinenr, $rawline);
3911                                 my $fixedline = rtrim($prevrawline) . " {";
3912                                 fix_insert_line($fixlinenr, $fixedline);
3913                                 $fixedline = $rawline;
3914                                 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
3915                                 if ($fixedline !~ /^\+\s*$/) {
3916                                         fix_insert_line($fixlinenr, $fixedline);
3917                                 }
3918                         }
3919                 }
3920
3921 # missing space after union, struct or enum definition
3922                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3923                         if (WARN("SPACING",
3924                                  "missing space after $1 definition\n" . $herecurr) &&
3925                             $fix) {
3926                                 $fixed[$fixlinenr] =~
3927                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3928                         }
3929                 }
3930
3931 # Function pointer declarations
3932 # check spacing between type, funcptr, and args
3933 # canonical declaration is "type (*funcptr)(args...)"
3934                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3935                         my $declare = $1;
3936                         my $pre_pointer_space = $2;
3937                         my $post_pointer_space = $3;
3938                         my $funcname = $4;
3939                         my $post_funcname_space = $5;
3940                         my $pre_args_space = $6;
3941
3942 # the $Declare variable will capture all spaces after the type
3943 # so check it for a missing trailing missing space but pointer return types
3944 # don't need a space so don't warn for those.
3945                         my $post_declare_space = "";
3946                         if ($declare =~ /(\s+)$/) {
3947                                 $post_declare_space = $1;
3948                                 $declare = rtrim($declare);
3949                         }
3950                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3951                                 WARN("SPACING",
3952                                      "missing space after return type\n" . $herecurr);
3953                                 $post_declare_space = " ";
3954                         }
3955
3956 # unnecessary space "type  (*funcptr)(args...)"
3957 # This test is not currently implemented because these declarations are
3958 # equivalent to
3959 #       int  foo(int bar, ...)
3960 # and this is form shouldn't/doesn't generate a checkpatch warning.
3961 #
3962 #                       elsif ($declare =~ /\s{2,}$/) {
3963 #                               WARN("SPACING",
3964 #                                    "Multiple spaces after return type\n" . $herecurr);
3965 #                       }
3966
3967 # unnecessary space "type ( *funcptr)(args...)"
3968                         if (defined $pre_pointer_space &&
3969                             $pre_pointer_space =~ /^\s/) {
3970                                 WARN("SPACING",
3971                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3972                         }
3973
3974 # unnecessary space "type (* funcptr)(args...)"
3975                         if (defined $post_pointer_space &&
3976                             $post_pointer_space =~ /^\s/) {
3977                                 WARN("SPACING",
3978                                      "Unnecessary space before function pointer name\n" . $herecurr);
3979                         }
3980
3981 # unnecessary space "type (*funcptr )(args...)"
3982                         if (defined $post_funcname_space &&
3983                             $post_funcname_space =~ /^\s/) {
3984                                 WARN("SPACING",
3985                                      "Unnecessary space after function pointer name\n" . $herecurr);
3986                         }
3987
3988 # unnecessary space "type (*funcptr) (args...)"
3989                         if (defined $pre_args_space &&
3990                             $pre_args_space =~ /^\s/) {
3991                                 WARN("SPACING",
3992                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
3993                         }
3994
3995                         if (show_type("SPACING") && $fix) {
3996                                 $fixed[$fixlinenr] =~
3997                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3998                         }
3999                 }
4000
4001 # check for spacing round square brackets; allowed:
4002 #  1. with a type on the left -- int [] a;
4003 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4004 #  3. inside a curly brace -- = { [0...10] = 5 }
4005                 while ($line =~ /(.*?\s)\[/g) {
4006                         my ($where, $prefix) = ($-[1], $1);
4007                         if ($prefix !~ /$Type\s+$/ &&
4008                             ($where != 0 || $prefix !~ /^.\s+$/) &&
4009                             $prefix !~ /[{,]\s+$/) {
4010                                 if (ERROR("BRACKET_SPACE",
4011                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
4012                                     $fix) {
4013                                     $fixed[$fixlinenr] =~
4014                                         s/^(\+.*?)\s+\[/$1\[/;
4015                                 }
4016                         }
4017                 }
4018
4019 # check for spaces between functions and their parentheses.
4020                 while ($line =~ /($Ident)\s+\(/g) {
4021                         my $name = $1;
4022                         my $ctx_before = substr($line, 0, $-[1]);
4023                         my $ctx = "$ctx_before$name";
4024
4025                         # Ignore those directives where spaces _are_ permitted.
4026                         if ($name =~ /^(?:
4027                                 if|for|while|switch|return|case|
4028                                 volatile|__volatile__|
4029                                 __attribute__|format|__extension__|
4030                                 asm|__asm__)$/x)
4031                         {
4032                         # cpp #define statements have non-optional spaces, ie
4033                         # if there is a space between the name and the open
4034                         # parenthesis it is simply not a parameter group.
4035                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4036
4037                         # cpp #elif statement condition may start with a (
4038                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4039
4040                         # If this whole things ends with a type its most
4041                         # likely a typedef for a function.
4042                         } elsif ($ctx =~ /$Type$/) {
4043
4044                         } else {
4045                                 if (WARN("SPACING",
4046                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4047                                              $fix) {
4048                                         $fixed[$fixlinenr] =~
4049                                             s/\b$name\s+\(/$name\(/;
4050                                 }
4051                         }
4052                 }
4053
4054 # Check operator spacing.
4055                 if (!($line=~/\#\s*include/)) {
4056                         my $fixed_line = "";
4057                         my $line_fixed = 0;
4058
4059                         my $ops = qr{
4060                                 <<=|>>=|<=|>=|==|!=|
4061                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4062                                 =>|->|<<|>>|<|>|=|!|~|
4063                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4064                                 \?:|\?|:
4065                         }x;
4066                         my @elements = split(/($ops|;)/, $opline);
4067
4068 ##                      print("element count: <" . $#elements . ">\n");
4069 ##                      foreach my $el (@elements) {
4070 ##                              print("el: <$el>\n");
4071 ##                      }
4072
4073                         my @fix_elements = ();
4074                         my $off = 0;
4075
4076                         foreach my $el (@elements) {
4077                                 push(@fix_elements, substr($rawline, $off, length($el)));
4078                                 $off += length($el);
4079                         }
4080
4081                         $off = 0;
4082
4083                         my $blank = copy_spacing($opline);
4084                         my $last_after = -1;
4085
4086                         for (my $n = 0; $n < $#elements; $n += 2) {
4087
4088                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4089
4090 ##                              print("n: <$n> good: <$good>\n");
4091
4092                                 $off += length($elements[$n]);
4093
4094                                 # Pick up the preceding and succeeding characters.
4095                                 my $ca = substr($opline, 0, $off);
4096                                 my $cc = '';
4097                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4098                                         $cc = substr($opline, $off + length($elements[$n + 1]));
4099                                 }
4100                                 my $cb = "$ca$;$cc";
4101
4102                                 my $a = '';
4103                                 $a = 'V' if ($elements[$n] ne '');
4104                                 $a = 'W' if ($elements[$n] =~ /\s$/);
4105                                 $a = 'C' if ($elements[$n] =~ /$;$/);
4106                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4107                                 $a = 'O' if ($elements[$n] eq '');
4108                                 $a = 'E' if ($ca =~ /^\s*$/);
4109
4110                                 my $op = $elements[$n + 1];
4111
4112                                 my $c = '';
4113                                 if (defined $elements[$n + 2]) {
4114                                         $c = 'V' if ($elements[$n + 2] ne '');
4115                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4116                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4117                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4118                                         $c = 'O' if ($elements[$n + 2] eq '');
4119                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4120                                 } else {
4121                                         $c = 'E';
4122                                 }
4123
4124                                 my $ctx = "${a}x${c}";
4125
4126                                 my $at = "(ctx:$ctx)";
4127
4128                                 my $ptr = substr($blank, 0, $off) . "^";
4129                                 my $hereptr = "$hereline$ptr\n";
4130
4131                                 # Pull out the value of this operator.
4132                                 my $op_type = substr($curr_values, $off + 1, 1);
4133
4134                                 # Get the full operator variant.
4135                                 my $opv = $op . substr($curr_vars, $off, 1);
4136
4137                                 # Ignore operators passed as parameters.
4138                                 if ($op_type ne 'V' &&
4139                                     $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4140
4141 #                               # Ignore comments
4142 #                               } elsif ($op =~ /^$;+$/) {
4143
4144                                 # ; should have either the end of line or a space or \ after it
4145                                 } elsif ($op eq ';') {
4146                                         if ($ctx !~ /.x[WEBC]/ &&
4147                                             $cc !~ /^\\/ && $cc !~ /^;/) {
4148                                                 if (ERROR("SPACING",
4149                                                           "space required after that '$op' $at\n" . $hereptr)) {
4150                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4151                                                         $line_fixed = 1;
4152                                                 }
4153                                         }
4154
4155                                 # // is a comment
4156                                 } elsif ($op eq '//') {
4157
4158                                 #   :   when part of a bitfield
4159                                 } elsif ($opv eq ':B') {
4160                                         # skip the bitfield test for now
4161
4162                                 # No spaces for:
4163                                 #   ->
4164                                 } elsif ($op eq '->') {
4165                                         if ($ctx =~ /Wx.|.xW/) {
4166                                                 if (ERROR("SPACING",
4167                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4168                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4169                                                         if (defined $fix_elements[$n + 2]) {
4170                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4171                                                         }
4172                                                         $line_fixed = 1;
4173                                                 }
4174                                         }
4175
4176                                 # , must not have a space before and must have a space on the right.
4177                                 } elsif ($op eq ',') {
4178                                         my $rtrim_before = 0;
4179                                         my $space_after = 0;
4180                                         if ($ctx =~ /Wx./) {
4181                                                 if (ERROR("SPACING",
4182                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
4183                                                         $line_fixed = 1;
4184                                                         $rtrim_before = 1;
4185                                                 }
4186                                         }
4187                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4188                                                 if (ERROR("SPACING",
4189                                                           "space required after that '$op' $at\n" . $hereptr)) {
4190                                                         $line_fixed = 1;
4191                                                         $last_after = $n;
4192                                                         $space_after = 1;
4193                                                 }
4194                                         }
4195                                         if ($rtrim_before || $space_after) {
4196                                                 if ($rtrim_before) {
4197                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4198                                                 } else {
4199                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4200                                                 }
4201                                                 if ($space_after) {
4202                                                         $good .= " ";
4203                                                 }
4204                                         }
4205
4206                                 # '*' as part of a type definition -- reported already.
4207                                 } elsif ($opv eq '*_') {
4208                                         #warn "'*' is part of type\n";
4209
4210                                 # unary operators should have a space before and
4211                                 # none after.  May be left adjacent to another
4212                                 # unary operator, or a cast
4213                                 } elsif ($op eq '!' || $op eq '~' ||
4214                                          $opv eq '*U' || $opv eq '-U' ||
4215                                          $opv eq '&U' || $opv eq '&&U') {
4216                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4217                                                 if (ERROR("SPACING",
4218                                                           "space required before that '$op' $at\n" . $hereptr)) {
4219                                                         if ($n != $last_after + 2) {
4220                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4221                                                                 $line_fixed = 1;
4222                                                         }
4223                                                 }
4224                                         }
4225                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4226                                                 # A unary '*' may be const
4227
4228                                         } elsif ($ctx =~ /.xW/) {
4229                                                 if (ERROR("SPACING",
4230                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
4231                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4232                                                         if (defined $fix_elements[$n + 2]) {
4233                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4234                                                         }
4235                                                         $line_fixed = 1;
4236                                                 }
4237                                         }
4238
4239                                 # unary ++ and unary -- are allowed no space on one side.
4240                                 } elsif ($op eq '++' or $op eq '--') {
4241                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4242                                                 if (ERROR("SPACING",
4243                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
4244                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4245                                                         $line_fixed = 1;
4246                                                 }
4247                                         }
4248                                         if ($ctx =~ /Wx[BE]/ ||
4249                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4250                                                 if (ERROR("SPACING",
4251                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
4252                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4253                                                         $line_fixed = 1;
4254                                                 }
4255                                         }
4256                                         if ($ctx =~ /ExW/) {
4257                                                 if (ERROR("SPACING",
4258                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
4259                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4260                                                         if (defined $fix_elements[$n + 2]) {
4261                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4262                                                         }
4263                                                         $line_fixed = 1;
4264                                                 }
4265                                         }
4266
4267                                 # << and >> may either have or not have spaces both sides
4268                                 } elsif ($op eq '<<' or $op eq '>>' or
4269                                          $op eq '&' or $op eq '^' or $op eq '|' or
4270                                          $op eq '+' or $op eq '-' or
4271                                          $op eq '*' or $op eq '/' or
4272                                          $op eq '%')
4273                                 {
4274                                         if ($check) {
4275                                                 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4276                                                         if (CHK("SPACING",
4277                                                                 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4278                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4279                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4280                                                                 $line_fixed = 1;
4281                                                         }
4282                                                 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4283                                                         if (CHK("SPACING",
4284                                                                 "space preferred before that '$op' $at\n" . $hereptr)) {
4285                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4286                                                                 $line_fixed = 1;
4287                                                         }
4288                                                 }
4289                                         } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4290                                                 if (ERROR("SPACING",
4291                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
4292                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4293                                                         if (defined $fix_elements[$n + 2]) {
4294                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4295                                                         }
4296                                                         $line_fixed = 1;
4297                                                 }
4298                                         }
4299
4300                                 # A colon needs no spaces before when it is
4301                                 # terminating a case value or a label.
4302                                 } elsif ($opv eq ':C' || $opv eq ':L') {
4303                                         if ($ctx =~ /Wx./) {
4304                                                 if (ERROR("SPACING",
4305                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
4306                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4307                                                         $line_fixed = 1;
4308                                                 }
4309                                         }
4310
4311                                 # All the others need spaces both sides.
4312                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4313                                         my $ok = 0;
4314
4315                                         # Ignore email addresses <foo@bar>
4316                                         if (($op eq '<' &&
4317                                              $cc =~ /^\S+\@\S+>/) ||
4318                                             ($op eq '>' &&
4319                                              $ca =~ /<\S+\@\S+$/))
4320                                         {
4321                                                 $ok = 1;
4322                                         }
4323
4324                                         # for asm volatile statements
4325                                         # ignore a colon with another
4326                                         # colon immediately before or after
4327                                         if (($op eq ':') &&
4328                                             ($ca =~ /:$/ || $cc =~ /^:/)) {
4329                                                 $ok = 1;
4330                                         }
4331
4332                                         # messages are ERROR, but ?: are CHK
4333                                         if ($ok == 0) {
4334                                                 my $msg_level = \&ERROR;
4335                                                 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4336
4337                                                 if (&{$msg_level}("SPACING",
4338                                                                   "spaces required around that '$op' $at\n" . $hereptr)) {
4339                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4340                                                         if (defined $fix_elements[$n + 2]) {
4341                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4342                                                         }
4343                                                         $line_fixed = 1;
4344                                                 }
4345                                         }
4346                                 }
4347                                 $off += length($elements[$n + 1]);
4348
4349 ##                              print("n: <$n> GOOD: <$good>\n");
4350
4351                                 $fixed_line = $fixed_line . $good;
4352                         }
4353
4354                         if (($#elements % 2) == 0) {
4355                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
4356                         }
4357
4358                         if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4359                                 $fixed[$fixlinenr] = $fixed_line;
4360                         }
4361
4362
4363                 }
4364
4365 # check for whitespace before a non-naked semicolon
4366                 if ($line =~ /^\+.*\S\s+;\s*$/) {
4367                         if (WARN("SPACING",
4368                                  "space prohibited before semicolon\n" . $herecurr) &&
4369                             $fix) {
4370                                 1 while $fixed[$fixlinenr] =~
4371                                     s/^(\+.*\S)\s+;/$1;/;
4372                         }
4373                 }
4374
4375 # check for multiple assignments
4376                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4377                         CHK("MULTIPLE_ASSIGNMENTS",
4378                             "multiple assignments should be avoided\n" . $herecurr);
4379                 }
4380
4381 ## # check for multiple declarations, allowing for a function declaration
4382 ## # continuation.
4383 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4384 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4385 ##
4386 ##                      # Remove any bracketed sections to ensure we do not
4387 ##                      # falsly report the parameters of functions.
4388 ##                      my $ln = $line;
4389 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
4390 ##                      }
4391 ##                      if ($ln =~ /,/) {
4392 ##                              WARN("MULTIPLE_DECLARATION",
4393 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
4394 ##                      }
4395 ##              }
4396
4397 #need space before brace following if, while, etc
4398                 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4399                     $line =~ /do\{/) {
4400                         if (ERROR("SPACING",
4401                                   "space required before the open brace '{'\n" . $herecurr) &&
4402                             $fix) {
4403                                 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
4404                         }
4405                 }
4406
4407 ## # check for blank lines before declarations
4408 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4409 ##                  $prevrawline =~ /^.\s*$/) {
4410 ##                      WARN("SPACING",
4411 ##                           "No blank lines before declarations\n" . $hereprev);
4412 ##              }
4413 ##
4414
4415 # closing brace should have a space following it when it has anything
4416 # on the line
4417                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4418                         if (ERROR("SPACING",
4419                                   "space required after that close brace '}'\n" . $herecurr) &&
4420                             $fix) {
4421                                 $fixed[$fixlinenr] =~
4422                                     s/}((?!(?:,|;|\)))\S)/} $1/;
4423                         }
4424                 }
4425
4426 # check spacing on square brackets
4427                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4428                         if (ERROR("SPACING",
4429                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
4430                             $fix) {
4431                                 $fixed[$fixlinenr] =~
4432                                     s/\[\s+/\[/;
4433                         }
4434                 }
4435                 if ($line =~ /\s\]/) {
4436                         if (ERROR("SPACING",
4437                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4438                             $fix) {
4439                                 $fixed[$fixlinenr] =~
4440                                     s/\s+\]/\]/;
4441                         }
4442                 }
4443
4444 # check spacing on parentheses
4445                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4446                     $line !~ /for\s*\(\s+;/) {
4447                         if (ERROR("SPACING",
4448                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4449                             $fix) {
4450                                 $fixed[$fixlinenr] =~
4451                                     s/\(\s+/\(/;
4452                         }
4453                 }
4454                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4455                     $line !~ /for\s*\(.*;\s+\)/ &&
4456                     $line !~ /:\s+\)/) {
4457                         if (ERROR("SPACING",
4458                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4459                             $fix) {
4460                                 $fixed[$fixlinenr] =~
4461                                     s/\s+\)/\)/;
4462                         }
4463                 }
4464
4465 # check unnecessary parentheses around addressof/dereference single $Lvals
4466 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4467
4468                 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4469                         my $var = $1;
4470                         if (CHK("UNNECESSARY_PARENTHESES",
4471                                 "Unnecessary parentheses around $var\n" . $herecurr) &&
4472                             $fix) {
4473                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4474                         }
4475                 }
4476
4477 # check for unnecessary parentheses around function pointer uses
4478 # ie: (foo->bar)(); should be foo->bar();
4479 # but not "if (foo->bar) (" to avoid some false positives
4480                 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4481                         my $var = $2;
4482                         if (CHK("UNNECESSARY_PARENTHESES",
4483                                 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4484                             $fix) {
4485                                 my $var2 = deparenthesize($var);
4486                                 $var2 =~ s/\s//g;
4487                                 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4488                         }
4489                 }
4490
4491 # check for unnecessary parentheses around comparisons in if uses
4492                 if ($^V && $^V ge 5.10.0 && defined($stat) &&
4493                     $stat =~ /(^.\s*if\s*($balanced_parens))/) {
4494                         my $if_stat = $1;
4495                         my $test = substr($2, 1, -1);
4496                         my $herectx;
4497                         while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
4498                                 my $match = $1;
4499                                 # avoid parentheses around potential macro args
4500                                 next if ($match =~ /^\s*\w+\s*$/);
4501                                 if (!defined($herectx)) {
4502                                         $herectx = $here . "\n";
4503                                         my $cnt = statement_rawlines($if_stat);
4504                                         for (my $n = 0; $n < $cnt; $n++) {
4505                                                 my $rl = raw_line($linenr, $n);
4506                                                 $herectx .=  $rl . "\n";
4507                                                 last if $rl =~ /^[ \+].*\{/;
4508                                         }
4509                                 }
4510                                 CHK("UNNECESSARY_PARENTHESES",
4511                                     "Unnecessary parentheses around '$match'\n" . $herectx);
4512                         }
4513                 }
4514
4515 #goto labels aren't indented, allow a single space however
4516                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4517                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4518                         if (WARN("INDENTED_LABEL",
4519                                  "labels should not be indented\n" . $herecurr) &&
4520                             $fix) {
4521                                 $fixed[$fixlinenr] =~
4522                                     s/^(.)\s+/$1/;
4523                         }
4524                 }
4525
4526 # return is not a function
4527                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4528                         my $spacing = $1;
4529                         if ($^V && $^V ge 5.10.0 &&
4530                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4531                                 my $value = $1;
4532                                 $value = deparenthesize($value);
4533                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4534                                         ERROR("RETURN_PARENTHESES",
4535                                               "return is not a function, parentheses are not required\n" . $herecurr);
4536                                 }
4537                         } elsif ($spacing !~ /\s+/) {
4538                                 ERROR("SPACING",
4539                                       "space required before the open parenthesis '('\n" . $herecurr);
4540                         }
4541                 }
4542
4543 # unnecessary return in a void function
4544 # at end-of-function, with the previous line a single leading tab, then return;
4545 # and the line before that not a goto label target like "out:"
4546                 if ($sline =~ /^[ \+]}\s*$/ &&
4547                     $prevline =~ /^\+\treturn\s*;\s*$/ &&
4548                     $linenr >= 3 &&
4549                     $lines[$linenr - 3] =~ /^[ +]/ &&
4550                     $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4551                         WARN("RETURN_VOID",
4552                              "void function return statements are not generally useful\n" . $hereprev);
4553                }
4554
4555 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4556                 if ($^V && $^V ge 5.10.0 &&
4557                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
4558                         my $openparens = $1;
4559                         my $count = $openparens =~ tr@\(@\(@;
4560                         my $msg = "";
4561                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4562                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
4563                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
4564                                 WARN("UNNECESSARY_PARENTHESES",
4565                                      "Unnecessary parentheses$msg\n" . $herecurr);
4566                         }
4567                 }
4568
4569 # comparisons with a constant or upper case identifier on the left
4570 #       avoid cases like "foo + BAR < baz"
4571 #       only fix matches surrounded by parentheses to avoid incorrect
4572 #       conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4573                 if ($^V && $^V ge 5.10.0 &&
4574                     $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4575                         my $lead = $1;
4576                         my $const = $2;
4577                         my $comp = $3;
4578                         my $to = $4;
4579                         my $newcomp = $comp;
4580                         if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4581                             $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4582                             WARN("CONSTANT_COMPARISON",
4583                                  "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4584                             $fix) {
4585                                 if ($comp eq "<") {
4586                                         $newcomp = ">";
4587                                 } elsif ($comp eq "<=") {
4588                                         $newcomp = ">=";
4589                                 } elsif ($comp eq ">") {
4590                                         $newcomp = "<";
4591                                 } elsif ($comp eq ">=") {
4592                                         $newcomp = "<=";
4593                                 }
4594                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4595                         }
4596                 }
4597
4598 # Return of what appears to be an errno should normally be negative
4599                 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4600                         my $name = $1;
4601                         if ($name ne 'EOF' && $name ne 'ERROR') {
4602                                 WARN("USE_NEGATIVE_ERRNO",
4603                                      "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4604                         }
4605                 }
4606
4607 # Need a space before open parenthesis after if, while etc
4608                 if ($line =~ /\b(if|while|for|switch)\(/) {
4609                         if (ERROR("SPACING",
4610                                   "space required before the open parenthesis '('\n" . $herecurr) &&
4611                             $fix) {
4612                                 $fixed[$fixlinenr] =~
4613                                     s/\b(if|while|for|switch)\(/$1 \(/;
4614                         }
4615                 }
4616
4617 # Check for illegal assignment in if conditional -- and check for trailing
4618 # statements after the conditional.
4619                 if ($line =~ /do\s*(?!{)/) {
4620                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4621                                 ctx_statement_block($linenr, $realcnt, 0)
4622                                         if (!defined $stat);
4623                         my ($stat_next) = ctx_statement_block($line_nr_next,
4624                                                 $remain_next, $off_next);
4625                         $stat_next =~ s/\n./\n /g;
4626                         ##print "stat<$stat> stat_next<$stat_next>\n";
4627
4628                         if ($stat_next =~ /^\s*while\b/) {
4629                                 # If the statement carries leading newlines,
4630                                 # then count those as offsets.
4631                                 my ($whitespace) =
4632                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4633                                 my $offset =
4634                                         statement_rawlines($whitespace) - 1;
4635
4636                                 $suppress_whiletrailers{$line_nr_next +
4637                                                                 $offset} = 1;
4638                         }
4639                 }
4640                 if (!defined $suppress_whiletrailers{$linenr} &&
4641                     defined($stat) && defined($cond) &&
4642                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4643                         my ($s, $c) = ($stat, $cond);
4644
4645                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4646                                 ERROR("ASSIGN_IN_IF",
4647                                       "do not use assignment in if condition\n" . $herecurr);
4648                         }
4649
4650                         # Find out what is on the end of the line after the
4651                         # conditional.
4652                         substr($s, 0, length($c), '');
4653                         $s =~ s/\n.*//g;
4654                         $s =~ s/$;//g;  # Remove any comments
4655                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4656                             $c !~ /}\s*while\s*/)
4657                         {
4658                                 # Find out how long the conditional actually is.
4659                                 my @newlines = ($c =~ /\n/gs);
4660                                 my $cond_lines = 1 + $#newlines;
4661                                 my $stat_real = '';
4662
4663                                 $stat_real = raw_line($linenr, $cond_lines)
4664                                                         . "\n" if ($cond_lines);
4665                                 if (defined($stat_real) && $cond_lines > 1) {
4666                                         $stat_real = "[...]\n$stat_real";
4667                                 }
4668
4669                                 ERROR("TRAILING_STATEMENTS",
4670                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
4671                         }
4672                 }
4673
4674 # Check for bitwise tests written as boolean
4675                 if ($line =~ /
4676                         (?:
4677                                 (?:\[|\(|\&\&|\|\|)
4678                                 \s*0[xX][0-9]+\s*
4679                                 (?:\&\&|\|\|)
4680                         |
4681                                 (?:\&\&|\|\|)
4682                                 \s*0[xX][0-9]+\s*
4683                                 (?:\&\&|\|\||\)|\])
4684                         )/x)
4685                 {
4686                         WARN("HEXADECIMAL_BOOLEAN_TEST",
4687                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4688                 }
4689
4690 # if and else should not have general statements after it
4691                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4692                         my $s = $1;
4693                         $s =~ s/$;//g;  # Remove any comments
4694                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4695                                 ERROR("TRAILING_STATEMENTS",
4696                                       "trailing statements should be on next line\n" . $herecurr);
4697                         }
4698                 }
4699 # if should not continue a brace
4700                 if ($line =~ /}\s*if\b/) {
4701                         ERROR("TRAILING_STATEMENTS",
4702                               "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4703                                 $herecurr);
4704                 }
4705 # case and default should not have general statements after them
4706                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4707                     $line !~ /\G(?:
4708                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4709                         \s*return\s+
4710                     )/xg)
4711                 {
4712                         ERROR("TRAILING_STATEMENTS",
4713                               "trailing statements should be on next line\n" . $herecurr);
4714                 }
4715
4716                 # Check for }<nl>else {, these must be at the same
4717                 # indent level to be relevant to each other.
4718                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4719                     $previndent == $indent) {
4720                         if (ERROR("ELSE_AFTER_BRACE",
4721                                   "else should follow close brace '}'\n" . $hereprev) &&
4722                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4723                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4724                                 fix_delete_line($fixlinenr, $rawline);
4725                                 my $fixedline = $prevrawline;
4726                                 $fixedline =~ s/}\s*$//;
4727                                 if ($fixedline !~ /^\+\s*$/) {
4728                                         fix_insert_line($fixlinenr, $fixedline);
4729                                 }
4730                                 $fixedline = $rawline;
4731                                 $fixedline =~ s/^(.\s*)else/$1} else/;
4732                                 fix_insert_line($fixlinenr, $fixedline);
4733                         }
4734                 }
4735
4736                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4737                     $previndent == $indent) {
4738                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4739
4740                         # Find out what is on the end of the line after the
4741                         # conditional.
4742                         substr($s, 0, length($c), '');
4743                         $s =~ s/\n.*//g;
4744
4745                         if ($s =~ /^\s*;/) {
4746                                 if (ERROR("WHILE_AFTER_BRACE",
4747                                           "while should follow close brace '}'\n" . $hereprev) &&
4748                                     $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4749                                         fix_delete_line($fixlinenr - 1, $prevrawline);
4750                                         fix_delete_line($fixlinenr, $rawline);
4751                                         my $fixedline = $prevrawline;
4752                                         my $trailing = $rawline;
4753                                         $trailing =~ s/^\+//;
4754                                         $trailing = trim($trailing);
4755                                         $fixedline =~ s/}\s*$/} $trailing/;
4756                                         fix_insert_line($fixlinenr, $fixedline);
4757                                 }
4758                         }
4759                 }
4760
4761 #Specific variable tests
4762                 while ($line =~ m{($Constant|$Lval)}g) {
4763                         my $var = $1;
4764
4765 #gcc binary extension
4766                         if ($var =~ /^$Binary$/) {
4767                                 if (WARN("GCC_BINARY_CONSTANT",
4768                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4769                                     $fix) {
4770                                         my $hexval = sprintf("0x%x", oct($var));
4771                                         $fixed[$fixlinenr] =~
4772                                             s/\b$var\b/$hexval/;
4773                                 }
4774                         }
4775
4776 #CamelCase
4777                         if ($var !~ /^$Constant$/ &&
4778                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4779 #Ignore Page<foo> variants
4780                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4781 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4782                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4783 #Ignore some three character SI units explicitly, like MiB and KHz
4784                             $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4785                                 while ($var =~ m{($Ident)}g) {
4786                                         my $word = $1;
4787                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4788                                         if ($check) {
4789                                                 seed_camelcase_includes();
4790                                                 if (!$file && !$camelcase_file_seeded) {
4791                                                         seed_camelcase_file($realfile);
4792                                                         $camelcase_file_seeded = 1;
4793                                                 }
4794                                         }
4795                                         if (!defined $camelcase{$word}) {
4796                                                 $camelcase{$word} = 1;
4797                                                 CHK("CAMELCASE",
4798                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
4799                                         }
4800                                 }
4801                         }
4802                 }
4803
4804 #no spaces allowed after \ in define
4805                 if ($line =~ /\#\s*define.*\\\s+$/) {
4806                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4807                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4808                             $fix) {
4809                                 $fixed[$fixlinenr] =~ s/\s+$//;
4810                         }
4811                 }
4812
4813 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4814 # itself <asm/foo.h> (uses RAW line)
4815                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4816                         my $file = "$1.h";
4817                         my $checkfile = "include/linux/$file";
4818                         if (-f "$root/$checkfile" &&
4819                             $realfile ne $checkfile &&
4820                             $1 !~ /$allowed_asm_includes/)
4821                         {
4822                                 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4823                                 if ($asminclude > 0) {
4824                                         if ($realfile =~ m{^arch/}) {
4825                                                 CHK("ARCH_INCLUDE_LINUX",
4826                                                     "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4827                                         } else {
4828                                                 WARN("INCLUDE_LINUX",
4829                                                      "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4830                                         }
4831                                 }
4832                         }
4833                 }
4834
4835 # multi-statement macros should be enclosed in a do while loop, grab the
4836 # first statement and ensure its the whole macro if its not enclosed
4837 # in a known good container
4838                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4839                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4840                         my $ln = $linenr;
4841                         my $cnt = $realcnt;
4842                         my ($off, $dstat, $dcond, $rest);
4843                         my $ctx = '';
4844                         my $has_flow_statement = 0;
4845                         my $has_arg_concat = 0;
4846                         ($dstat, $dcond, $ln, $cnt, $off) =
4847                                 ctx_statement_block($linenr, $realcnt, 0);
4848                         $ctx = $dstat;
4849                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4850                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4851
4852                         $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4853                         $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4854
4855                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4856                         my $define_args = $1;
4857                         my $define_stmt = $dstat;
4858                         my @def_args = ();
4859
4860                         if (defined $define_args && $define_args ne "") {
4861                                 $define_args = substr($define_args, 1, length($define_args) - 2);
4862                                 $define_args =~ s/\s*//g;
4863                                 @def_args = split(",", $define_args);
4864                         }
4865
4866                         $dstat =~ s/$;//g;
4867                         $dstat =~ s/\\\n.//g;
4868                         $dstat =~ s/^\s*//s;
4869                         $dstat =~ s/\s*$//s;
4870
4871                         # Flatten any parentheses and braces
4872                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4873                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
4874                                $dstat =~ s/.\[[^\[\]]*\]/1/)
4875                         {
4876                         }
4877
4878                         # Flatten any obvious string concatentation.
4879                         while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4880                                $dstat =~ s/$Ident\s*($String)/$1/)
4881                         {
4882                         }
4883
4884                         # Make asm volatile uses seem like a generic function
4885                         $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4886
4887                         my $exceptions = qr{
4888                                 $Declare|
4889                                 module_param_named|
4890                                 MODULE_PARM_DESC|
4891                                 DECLARE_PER_CPU|
4892                                 DEFINE_PER_CPU|
4893                                 __typeof__\(|
4894                                 union|
4895                                 struct|
4896                                 \.$Ident\s*=\s*|
4897                                 ^\"|\"$|
4898                                 ^\[
4899                         }x;
4900                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4901
4902                         $ctx =~ s/\n*$//;
4903                         my $herectx = $here . "\n";
4904                         my $stmt_cnt = statement_rawlines($ctx);
4905
4906                         for (my $n = 0; $n < $stmt_cnt; $n++) {
4907                                 $herectx .= raw_line($linenr, $n) . "\n";
4908                         }
4909
4910                         if ($dstat ne '' &&
4911                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
4912                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
4913                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4914                             $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&                  # character constants
4915                             $dstat !~ /$exceptions/ &&
4916                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
4917                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
4918                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
4919                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
4920                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
4921                             $dstat !~ /^do\s*{/ &&                                      # do {...
4922                             $dstat !~ /^\(\{/ &&                                                # ({...
4923                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4924                         {
4925                                 if ($dstat =~ /^\s*if\b/) {
4926                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4927                                               "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
4928                                 } elsif ($dstat =~ /;/) {
4929                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4930                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4931                                 } else {
4932                                         ERROR("COMPLEX_MACRO",
4933                                               "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4934                                 }
4935
4936                         }
4937
4938                         # Make $define_stmt single line, comment-free, etc
4939                         my @stmt_array = split('\n', $define_stmt);
4940                         my $first = 1;
4941                         $define_stmt = "";
4942                         foreach my $l (@stmt_array) {
4943                                 $l =~ s/\\$//;
4944                                 if ($first) {
4945                                         $define_stmt = $l;
4946                                         $first = 0;
4947                                 } elsif ($l =~ /^[\+ ]/) {
4948                                         $define_stmt .= substr($l, 1);
4949                                 }
4950                         }
4951                         $define_stmt =~ s/$;//g;
4952                         $define_stmt =~ s/\s+/ /g;
4953                         $define_stmt = trim($define_stmt);
4954
4955 # check if any macro arguments are reused (ignore '...' and 'type')
4956                         foreach my $arg (@def_args) {
4957                                 next if ($arg =~ /\.\.\./);
4958                                 next if ($arg =~ /^type$/i);
4959                                 my $tmp_stmt = $define_stmt;
4960                                 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4961                                 $tmp_stmt =~ s/\#+\s*$arg\b//g;
4962                                 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
4963                                 my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
4964                                 if ($use_cnt > 1) {
4965                                         CHK("MACRO_ARG_REUSE",
4966                                             "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
4967                                     }
4968 # check if any macro arguments may have other precedence issues
4969                                 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
4970                                     ((defined($1) && $1 ne ',') ||
4971                                      (defined($2) && $2 ne ','))) {
4972                                         CHK("MACRO_ARG_PRECEDENCE",
4973                                             "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
4974                                 }
4975                         }
4976
4977 # check for macros with flow control, but without ## concatenation
4978 # ## concatenation is commonly a macro that defines a function so ignore those
4979                         if ($has_flow_statement && !$has_arg_concat) {
4980                                 my $herectx = $here . "\n";
4981                                 my $cnt = statement_rawlines($ctx);
4982
4983                                 for (my $n = 0; $n < $cnt; $n++) {
4984                                         $herectx .= raw_line($linenr, $n) . "\n";
4985                                 }
4986                                 WARN("MACRO_WITH_FLOW_CONTROL",
4987                                      "Macros with flow control statements should be avoided\n" . "$herectx");
4988                         }
4989
4990 # check for line continuations outside of #defines, preprocessor #, and asm
4991
4992                 } else {
4993                         if ($prevline !~ /^..*\\$/ &&
4994                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
4995                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
4996                             $line =~ /^\+.*\\$/) {
4997                                 WARN("LINE_CONTINUATIONS",
4998                                      "Avoid unnecessary line continuations\n" . $herecurr);
4999                         }
5000                 }
5001
5002 # do {} while (0) macro tests:
5003 # single-statement macros do not need to be enclosed in do while (0) loop,
5004 # macro should not end with a semicolon
5005                 if ($^V && $^V ge 5.10.0 &&
5006                     $realfile !~ m@/vmlinux.lds.h$@ &&
5007                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5008                         my $ln = $linenr;
5009                         my $cnt = $realcnt;
5010                         my ($off, $dstat, $dcond, $rest);
5011                         my $ctx = '';
5012                         ($dstat, $dcond, $ln, $cnt, $off) =
5013                                 ctx_statement_block($linenr, $realcnt, 0);
5014                         $ctx = $dstat;
5015
5016                         $dstat =~ s/\\\n.//g;
5017                         $dstat =~ s/$;/ /g;
5018
5019                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5020                                 my $stmts = $2;
5021                                 my $semis = $3;
5022
5023                                 $ctx =~ s/\n*$//;
5024                                 my $cnt = statement_rawlines($ctx);
5025                                 my $herectx = $here . "\n";
5026
5027                                 for (my $n = 0; $n < $cnt; $n++) {
5028                                         $herectx .= raw_line($linenr, $n) . "\n";
5029                                 }
5030
5031                                 if (($stmts =~ tr/;/;/) == 1 &&
5032                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
5033                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5034                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5035                                 }
5036                                 if (defined $semis && $semis ne "") {
5037                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5038                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5039                                 }
5040                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5041                                 $ctx =~ s/\n*$//;
5042                                 my $cnt = statement_rawlines($ctx);
5043                                 my $herectx = $here . "\n";
5044
5045                                 for (my $n = 0; $n < $cnt; $n++) {
5046                                         $herectx .= raw_line($linenr, $n) . "\n";
5047                                 }
5048
5049                                 WARN("TRAILING_SEMICOLON",
5050                                      "macros should not use a trailing semicolon\n" . "$herectx");
5051                         }
5052                 }
5053
5054 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5055 # all assignments may have only one of the following with an assignment:
5056 #       .
5057 #       ALIGN(...)
5058 #       VMLINUX_SYMBOL(...)
5059                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
5060                         WARN("MISSING_VMLINUX_SYMBOL",
5061                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
5062                 }
5063
5064 # check for redundant bracing round if etc
5065                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5066                         my ($level, $endln, @chunks) =
5067                                 ctx_statement_full($linenr, $realcnt, 1);
5068                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5069                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5070                         if ($#chunks > 0 && $level == 0) {
5071                                 my @allowed = ();
5072                                 my $allow = 0;
5073                                 my $seen = 0;
5074                                 my $herectx = $here . "\n";
5075                                 my $ln = $linenr - 1;
5076                                 for my $chunk (@chunks) {
5077                                         my ($cond, $block) = @{$chunk};
5078
5079                                         # If the condition carries leading newlines, then count those as offsets.
5080                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5081                                         my $offset = statement_rawlines($whitespace) - 1;
5082
5083                                         $allowed[$allow] = 0;
5084                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5085
5086                                         # We have looked at and allowed this specific line.
5087                                         $suppress_ifbraces{$ln + $offset} = 1;
5088
5089                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5090                                         $ln += statement_rawlines($block) - 1;
5091
5092                                         substr($block, 0, length($cond), '');
5093
5094                                         $seen++ if ($block =~ /^\s*{/);
5095
5096                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5097                                         if (statement_lines($cond) > 1) {
5098                                                 #print "APW: ALLOWED: cond<$cond>\n";
5099                                                 $allowed[$allow] = 1;
5100                                         }
5101                                         if ($block =~/\b(?:if|for|while)\b/) {
5102                                                 #print "APW: ALLOWED: block<$block>\n";
5103                                                 $allowed[$allow] = 1;
5104                                         }
5105                                         if (statement_block_size($block) > 1) {
5106                                                 #print "APW: ALLOWED: lines block<$block>\n";
5107                                                 $allowed[$allow] = 1;
5108                                         }
5109                                         $allow++;
5110                                 }
5111                                 if ($seen) {
5112                                         my $sum_allowed = 0;
5113                                         foreach (@allowed) {
5114                                                 $sum_allowed += $_;
5115                                         }
5116                                         if ($sum_allowed == 0) {
5117                                                 WARN("BRACES",
5118                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
5119                                         } elsif ($sum_allowed != $allow &&
5120                                                  $seen != $allow) {
5121                                                 CHK("BRACES",
5122                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
5123                                         }
5124                                 }
5125                         }
5126                 }
5127                 if (!defined $suppress_ifbraces{$linenr - 1} &&
5128                                         $line =~ /\b(if|while|for|else)\b/) {
5129                         my $allowed = 0;
5130
5131                         # Check the pre-context.
5132                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5133                                 #print "APW: ALLOWED: pre<$1>\n";
5134                                 $allowed = 1;
5135                         }
5136
5137                         my ($level, $endln, @chunks) =
5138                                 ctx_statement_full($linenr, $realcnt, $-[0]);
5139
5140                         # Check the condition.
5141                         my ($cond, $block) = @{$chunks[0]};
5142                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5143                         if (defined $cond) {
5144                                 substr($block, 0, length($cond), '');
5145                         }
5146                         if (statement_lines($cond) > 1) {
5147                                 #print "APW: ALLOWED: cond<$cond>\n";
5148                                 $allowed = 1;
5149                         }
5150                         if ($block =~/\b(?:if|for|while)\b/) {
5151                                 #print "APW: ALLOWED: block<$block>\n";
5152                                 $allowed = 1;
5153                         }
5154                         if (statement_block_size($block) > 1) {
5155                                 #print "APW: ALLOWED: lines block<$block>\n";
5156                                 $allowed = 1;
5157                         }
5158                         # Check the post-context.
5159                         if (defined $chunks[1]) {
5160                                 my ($cond, $block) = @{$chunks[1]};
5161                                 if (defined $cond) {
5162                                         substr($block, 0, length($cond), '');
5163                                 }
5164                                 if ($block =~ /^\s*\{/) {
5165                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
5166                                         $allowed = 1;
5167                                 }
5168                         }
5169                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5170                                 my $herectx = $here . "\n";
5171                                 my $cnt = statement_rawlines($block);
5172
5173                                 for (my $n = 0; $n < $cnt; $n++) {
5174                                         $herectx .= raw_line($linenr, $n) . "\n";
5175                                 }
5176
5177                                 WARN("BRACES",
5178                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
5179                         }
5180                 }
5181
5182 # check for single line unbalanced braces
5183                 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5184                     $sline =~ /^.\s*else\s*\{\s*$/) {
5185                         CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5186                 }
5187
5188 # check for unnecessary blank lines around braces
5189                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5190                         if (CHK("BRACES",
5191                                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5192                             $fix && $prevrawline =~ /^\+/) {
5193                                 fix_delete_line($fixlinenr - 1, $prevrawline);
5194                         }
5195                 }
5196                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5197                         if (CHK("BRACES",
5198                                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5199                             $fix) {
5200                                 fix_delete_line($fixlinenr, $rawline);
5201                         }
5202                 }
5203
5204 # no volatiles please
5205                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5206                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5207                         WARN("VOLATILE",
5208                              "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5209                 }
5210
5211 # Check for user-visible strings broken across lines, which breaks the ability
5212 # to grep for the string.  Make exceptions when the previous string ends in a
5213 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5214 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5215                 if ($line =~ /^\+\s*$String/ &&
5216                     $prevline =~ /"\s*$/ &&
5217                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5218                         if (WARN("SPLIT_STRING",
5219                                  "quoted string split across lines\n" . $hereprev) &&
5220                                      $fix &&
5221                                      $prevrawline =~ /^\+.*"\s*$/ &&
5222                                      $last_coalesced_string_linenr != $linenr - 1) {
5223                                 my $extracted_string = get_quoted_string($line, $rawline);
5224                                 my $comma_close = "";
5225                                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5226                                         $comma_close = $1;
5227                                 }
5228
5229                                 fix_delete_line($fixlinenr - 1, $prevrawline);
5230                                 fix_delete_line($fixlinenr, $rawline);
5231                                 my $fixedline = $prevrawline;
5232                                 $fixedline =~ s/"\s*$//;
5233                                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5234                                 fix_insert_line($fixlinenr - 1, $fixedline);
5235                                 $fixedline = $rawline;
5236                                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5237                                 if ($fixedline !~ /\+\s*$/) {
5238                                         fix_insert_line($fixlinenr, $fixedline);
5239                                 }
5240                                 $last_coalesced_string_linenr = $linenr;
5241                         }
5242                 }
5243
5244 # check for missing a space in a string concatenation
5245                 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5246                         WARN('MISSING_SPACE',
5247                              "break quoted strings at a space character\n" . $hereprev);
5248                 }
5249
5250 # check for an embedded function name in a string when the function is known
5251 # This does not work very well for -f --file checking as it depends on patch
5252 # context providing the function name or a single line form for in-file
5253 # function declarations
5254                 if ($line =~ /^\+.*$String/ &&
5255                     defined($context_function) &&
5256                     get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5257                     length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5258                         WARN("EMBEDDED_FUNCTION_NAME",
5259                              "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5260                 }
5261
5262 # check for spaces before a quoted newline
5263                 if ($rawline =~ /^.*\".*\s\\n/) {
5264                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5265                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5266                             $fix) {
5267                                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5268                         }
5269
5270                 }
5271
5272 # concatenated string without spaces between elements
5273                 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5274                         CHK("CONCATENATED_STRING",
5275                             "Concatenated strings should use spaces between elements\n" . $herecurr);
5276                 }
5277
5278 # uncoalesced string fragments
5279                 if ($line =~ /$String\s*"/) {
5280                         WARN("STRING_FRAGMENTS",
5281                              "Consecutive strings are generally better as a single string\n" . $herecurr);
5282                 }
5283
5284 # check for non-standard and hex prefixed decimal printf formats
5285                 my $show_L = 1; #don't show the same defect twice
5286                 my $show_Z = 1;
5287                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5288                         my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5289                         $string =~ s/%%/__/g;
5290                         # check for %L
5291                         if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5292                                 WARN("PRINTF_L",
5293                                      "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5294                                 $show_L = 0;
5295                         }
5296                         # check for %Z
5297                         if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5298                                 WARN("PRINTF_Z",
5299                                      "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5300                                 $show_Z = 0;
5301                         }
5302                         # check for 0x<decimal>
5303                         if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5304                                 ERROR("PRINTF_0XDECIMAL",
5305                                       "Prefixing 0x with decimal output is defective\n" . $herecurr);
5306                         }
5307                 }
5308
5309 # check for line continuations in quoted strings with odd counts of "
5310                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5311                         WARN("LINE_CONTINUATIONS",
5312                              "Avoid line continuations in quoted strings\n" . $herecurr);
5313                 }
5314
5315 # warn about #if 0
5316                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5317                         CHK("REDUNDANT_CODE",
5318                             "if this code is redundant consider removing it\n" .
5319                                 $herecurr);
5320                 }
5321
5322 # check for needless "if (<foo>) fn(<foo>)" uses
5323                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5324                         my $tested = quotemeta($1);
5325                         my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5326                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5327                                 my $func = $1;
5328                                 if (WARN('NEEDLESS_IF',
5329                                          "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5330                                     $fix) {
5331                                         my $do_fix = 1;
5332                                         my $leading_tabs = "";
5333                                         my $new_leading_tabs = "";
5334                                         if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5335                                                 $leading_tabs = $1;
5336                                         } else {
5337                                                 $do_fix = 0;
5338                                         }
5339                                         if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5340                                                 $new_leading_tabs = $1;
5341                                                 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5342                                                         $do_fix = 0;
5343                                                 }
5344                                         } else {
5345                                                 $do_fix = 0;
5346                                         }
5347                                         if ($do_fix) {
5348                                                 fix_delete_line($fixlinenr - 1, $prevrawline);
5349                                                 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5350                                         }
5351                                 }
5352                         }
5353                 }
5354
5355 # check for unnecessary "Out of Memory" messages
5356                 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5357                     $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5358                     (defined $1 || defined $3) &&
5359                     $linenr > 3) {
5360                         my $testval = $2;
5361                         my $testline = $lines[$linenr - 3];
5362
5363                         my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5364 #                       print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5365
5366                         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)/) {
5367                                 WARN("OOM_MESSAGE",
5368                                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
5369                         }
5370                 }
5371
5372 # check for logging functions with KERN_<LEVEL>
5373                 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5374                     $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5375                         my $level = $1;
5376                         if (WARN("UNNECESSARY_KERN_LEVEL",
5377                                  "Possible unnecessary $level\n" . $herecurr) &&
5378                             $fix) {
5379                                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5380                         }
5381                 }
5382
5383 # check for logging continuations
5384                 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5385                         WARN("LOGGING_CONTINUATION",
5386                              "Avoid logging continuation uses where feasible\n" . $herecurr);
5387                 }
5388
5389 # check for mask then right shift without a parentheses
5390                 if ($^V && $^V ge 5.10.0 &&
5391                     $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5392                     $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5393                         WARN("MASK_THEN_SHIFT",
5394                              "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5395                 }
5396
5397 # check for pointer comparisons to NULL
5398                 if ($^V && $^V ge 5.10.0) {
5399                         while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5400                                 my $val = $1;
5401                                 my $equal = "!";
5402                                 $equal = "" if ($4 eq "!=");
5403                                 if (CHK("COMPARISON_TO_NULL",
5404                                         "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5405                                             $fix) {
5406                                         $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5407                                 }
5408                         }
5409                 }
5410
5411 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5412                 if ($line =~ /(\b$InitAttribute\b)/) {
5413                         my $attr = $1;
5414                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5415                                 my $ptr = $1;
5416                                 my $var = $2;
5417                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5418                                       ERROR("MISPLACED_INIT",
5419                                             "$attr should be placed after $var\n" . $herecurr)) ||
5420                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5421                                       WARN("MISPLACED_INIT",
5422                                            "$attr should be placed after $var\n" . $herecurr))) &&
5423                                     $fix) {
5424                                         $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;
5425                                 }
5426                         }
5427                 }
5428
5429 # check for $InitAttributeData (ie: __initdata) with const
5430                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5431                         my $attr = $1;
5432                         $attr =~ /($InitAttributePrefix)(.*)/;
5433                         my $attr_prefix = $1;
5434                         my $attr_type = $2;
5435                         if (ERROR("INIT_ATTRIBUTE",
5436                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5437                             $fix) {
5438                                 $fixed[$fixlinenr] =~
5439                                     s/$InitAttributeData/${attr_prefix}initconst/;
5440                         }
5441                 }
5442
5443 # check for $InitAttributeConst (ie: __initconst) without const
5444                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5445                         my $attr = $1;
5446                         if (ERROR("INIT_ATTRIBUTE",
5447                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
5448                             $fix) {
5449                                 my $lead = $fixed[$fixlinenr] =~
5450                                     /(^\+\s*(?:static\s+))/;
5451                                 $lead = rtrim($1);
5452                                 $lead = "$lead " if ($lead !~ /^\+$/);
5453                                 $lead = "${lead}const ";
5454                                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5455                         }
5456                 }
5457
5458 # check for __read_mostly with const non-pointer (should just be const)
5459                 if ($line =~ /\b__read_mostly\b/ &&
5460                     $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5461                         if (ERROR("CONST_READ_MOSTLY",
5462                                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5463                             $fix) {
5464                                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5465                         }
5466                 }
5467
5468 # don't use __constant_<foo> functions outside of include/uapi/
5469                 if ($realfile !~ m@^include/uapi/@ &&
5470                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5471                         my $constant_func = $1;
5472                         my $func = $constant_func;
5473                         $func =~ s/^__constant_//;
5474                         if (WARN("CONSTANT_CONVERSION",
5475                                  "$constant_func should be $func\n" . $herecurr) &&
5476                             $fix) {
5477                                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5478                         }
5479                 }
5480
5481 # prefer usleep_range over udelay
5482                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5483                         my $delay = $1;
5484                         # ignore udelay's < 10, however
5485                         if (! ($delay < 10) ) {
5486                                 CHK("USLEEP_RANGE",
5487                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5488                         }
5489                         if ($delay > 2000) {
5490                                 WARN("LONG_UDELAY",
5491                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5492                         }
5493                 }
5494
5495 # warn about unexpectedly long msleep's
5496                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5497                         if ($1 < 20) {
5498                                 WARN("MSLEEP",
5499                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5500                         }
5501                 }
5502
5503 # check for comparisons of jiffies
5504                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5505                         WARN("JIFFIES_COMPARISON",
5506                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5507                 }
5508
5509 # check for comparisons of get_jiffies_64()
5510                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5511                         WARN("JIFFIES_COMPARISON",
5512                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5513                 }
5514
5515 # warn about #ifdefs in C files
5516 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5517 #                       print "#ifdef in C files should be avoided\n";
5518 #                       print "$herecurr";
5519 #                       $clean = 0;
5520 #               }
5521
5522 # warn about spacing in #ifdefs
5523                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5524                         if (ERROR("SPACING",
5525                                   "exactly one space required after that #$1\n" . $herecurr) &&
5526                             $fix) {
5527                                 $fixed[$fixlinenr] =~
5528                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5529                         }
5530
5531                 }
5532
5533 # check for spinlock_t definitions without a comment.
5534                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5535                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5536                         my $which = $1;
5537                         if (!ctx_has_comment($first_line, $linenr)) {
5538                                 CHK("UNCOMMENTED_DEFINITION",
5539                                     "$1 definition without comment\n" . $herecurr);
5540                         }
5541                 }
5542 # check for memory barriers without a comment.
5543
5544                 my $barriers = qr{
5545                         mb|
5546                         rmb|
5547                         wmb|
5548                         read_barrier_depends
5549                 }x;
5550                 my $barrier_stems = qr{
5551                         mb__before_atomic|
5552                         mb__after_atomic|
5553                         store_release|
5554                         load_acquire|
5555                         store_mb|
5556                         (?:$barriers)
5557                 }x;
5558                 my $all_barriers = qr{
5559                         (?:$barriers)|
5560                         smp_(?:$barrier_stems)|
5561                         virt_(?:$barrier_stems)
5562                 }x;
5563
5564                 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5565                         if (!ctx_has_comment($first_line, $linenr)) {
5566                                 WARN("MEMORY_BARRIER",
5567                                      "memory barrier without comment\n" . $herecurr);
5568                         }
5569                 }
5570
5571                 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5572
5573                 if ($realfile !~ m@^include/asm-generic/@ &&
5574                     $realfile !~ m@/barrier\.h$@ &&
5575                     $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5576                     $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5577                         WARN("MEMORY_BARRIER",
5578                              "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5579                 }
5580
5581 # check for waitqueue_active without a comment.
5582                 if ($line =~ /\bwaitqueue_active\s*\(/) {
5583                         if (!ctx_has_comment($first_line, $linenr)) {
5584                                 WARN("WAITQUEUE_ACTIVE",
5585                                      "waitqueue_active without comment\n" . $herecurr);
5586                         }
5587                 }
5588
5589 # check of hardware specific defines
5590                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5591                         CHK("ARCH_DEFINES",
5592                             "architecture specific defines should be avoided\n" .  $herecurr);
5593                 }
5594
5595 # check that the storage class is not after a type
5596                 if ($line =~ /\b($Type)\s+($Storage)\b/) {
5597                         WARN("STORAGE_CLASS",
5598                              "storage class '$2' should be located before type '$1'\n" . $herecurr);
5599                 }
5600 # Check that the storage class is at the beginning of a declaration
5601                 if ($line =~ /\b$Storage\b/ &&
5602                     $line !~ /^.\s*$Storage/ &&
5603                     $line =~ /^.\s*(.+?)\$Storage\s/ &&
5604                     $1 !~ /[\,\)]\s*$/) {
5605                         WARN("STORAGE_CLASS",
5606                              "storage class should be at the beginning of the declaration\n" . $herecurr);
5607                 }
5608
5609 # check the location of the inline attribute, that it is between
5610 # storage class and type.
5611                 if ($line =~ /\b$Type\s+$Inline\b/ ||
5612                     $line =~ /\b$Inline\s+$Storage\b/) {
5613                         ERROR("INLINE_LOCATION",
5614                               "inline keyword should sit between storage class and type\n" . $herecurr);
5615                 }
5616
5617 # Check for __inline__ and __inline, prefer inline
5618                 if ($realfile !~ m@\binclude/uapi/@ &&
5619                     $line =~ /\b(__inline__|__inline)\b/) {
5620                         if (WARN("INLINE",
5621                                  "plain inline is preferred over $1\n" . $herecurr) &&
5622                             $fix) {
5623                                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5624
5625                         }
5626                 }
5627
5628 # Check for __attribute__ packed, prefer __packed
5629                 if ($realfile !~ m@\binclude/uapi/@ &&
5630                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5631                         WARN("PREFER_PACKED",
5632                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5633                 }
5634
5635 # Check for __attribute__ aligned, prefer __aligned
5636                 if ($realfile !~ m@\binclude/uapi/@ &&
5637                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5638                         WARN("PREFER_ALIGNED",
5639                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5640                 }
5641
5642 # Check for __attribute__ format(printf, prefer __printf
5643                 if ($realfile !~ m@\binclude/uapi/@ &&
5644                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5645                         if (WARN("PREFER_PRINTF",
5646                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5647                             $fix) {
5648                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5649
5650                         }
5651                 }
5652
5653 # Check for __attribute__ format(scanf, prefer __scanf
5654                 if ($realfile !~ m@\binclude/uapi/@ &&
5655                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5656                         if (WARN("PREFER_SCANF",
5657                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5658                             $fix) {
5659                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5660                         }
5661                 }
5662
5663 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5664                 if ($^V && $^V ge 5.10.0 &&
5665                     $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5666                     ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5667                      $line =~ /\b__weak\b/)) {
5668                         ERROR("WEAK_DECLARATION",
5669                               "Using weak declarations can have unintended link defects\n" . $herecurr);
5670                 }
5671
5672 # check for c99 types like uint8_t used outside of uapi/ and tools/
5673                 if ($realfile !~ m@\binclude/uapi/@ &&
5674                     $realfile !~ m@\btools/@ &&
5675                     $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5676                         my $type = $1;
5677                         if ($type =~ /\b($typeC99Typedefs)\b/) {
5678                                 $type = $1;
5679                                 my $kernel_type = 'u';
5680                                 $kernel_type = 's' if ($type =~ /^_*[si]/);
5681                                 $type =~ /(\d+)/;
5682                                 $kernel_type .= $1;
5683                                 if (CHK("PREFER_KERNEL_TYPES",
5684                                         "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5685                                     $fix) {
5686                                         $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5687                                 }
5688                         }
5689                 }
5690
5691 # check for cast of C90 native int or longer types constants
5692                 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5693                         my $cast = $1;
5694                         my $const = $2;
5695                         if (WARN("TYPECAST_INT_CONSTANT",
5696                                  "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5697                             $fix) {
5698                                 my $suffix = "";
5699                                 my $newconst = $const;
5700                                 $newconst =~ s/${Int_type}$//;
5701                                 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5702                                 if ($cast =~ /\blong\s+long\b/) {
5703                                         $suffix .= 'LL';
5704                                 } elsif ($cast =~ /\blong\b/) {
5705                                         $suffix .= 'L';
5706                                 }
5707                                 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5708                         }
5709                 }
5710
5711 # check for sizeof(&)
5712                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5713                         WARN("SIZEOF_ADDRESS",
5714                              "sizeof(& should be avoided\n" . $herecurr);
5715                 }
5716
5717 # check for sizeof without parenthesis
5718                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5719                         if (WARN("SIZEOF_PARENTHESIS",
5720                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5721                             $fix) {
5722                                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5723                         }
5724                 }
5725
5726 # check for struct spinlock declarations
5727                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5728                         WARN("USE_SPINLOCK_T",
5729                              "struct spinlock should be spinlock_t\n" . $herecurr);
5730                 }
5731
5732 # check for seq_printf uses that could be seq_puts
5733                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5734                         my $fmt = get_quoted_string($line, $rawline);
5735                         $fmt =~ s/%%//g;
5736                         if ($fmt !~ /%/) {
5737                                 if (WARN("PREFER_SEQ_PUTS",
5738                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5739                                     $fix) {
5740                                         $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5741                                 }
5742                         }
5743                 }
5744
5745                 # check for vsprintf extension %p<foo> misuses
5746                 if ($^V && $^V ge 5.10.0 &&
5747                     defined $stat &&
5748                     $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5749                     $1 !~ /^_*volatile_*$/) {
5750                         my $bad_extension = "";
5751                         my $lc = $stat =~ tr@\n@@;
5752                         $lc = $lc + $linenr;
5753                         for (my $count = $linenr; $count <= $lc; $count++) {
5754                                 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5755                                 $fmt =~ s/%%//g;
5756                                 if ($fmt =~ /(\%[\*\d\.]*p(?![\WFfSsBKRraEhMmIiUDdgVCbGNOx]).)/) {
5757                                         $bad_extension = $1;
5758                                         last;
5759                                 }
5760                         }
5761                         if ($bad_extension ne "") {
5762                                 my $stat_real = raw_line($linenr, 0);
5763                                 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5764                                         $stat_real = $stat_real . "\n" . raw_line($count, 0);
5765                                 }
5766                                 WARN("VSPRINTF_POINTER_EXTENSION",
5767                                      "Invalid vsprintf pointer extension '$bad_extension'\n" . "$here\n$stat_real\n");
5768                         }
5769                 }
5770
5771 # Check for misused memsets
5772                 if ($^V && $^V ge 5.10.0 &&
5773                     defined $stat &&
5774                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5775
5776                         my $ms_addr = $2;
5777                         my $ms_val = $7;
5778                         my $ms_size = $12;
5779
5780                         if ($ms_size =~ /^(0x|)0$/i) {
5781                                 ERROR("MEMSET",
5782                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5783                         } elsif ($ms_size =~ /^(0x|)1$/i) {
5784                                 WARN("MEMSET",
5785                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5786                         }
5787                 }
5788
5789 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5790 #               if ($^V && $^V ge 5.10.0 &&
5791 #                   defined $stat &&
5792 #                   $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5793 #                       if (WARN("PREFER_ETHER_ADDR_COPY",
5794 #                                "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5795 #                           $fix) {
5796 #                               $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5797 #                       }
5798 #               }
5799
5800 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5801 #               if ($^V && $^V ge 5.10.0 &&
5802 #                   defined $stat &&
5803 #                   $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5804 #                       WARN("PREFER_ETHER_ADDR_EQUAL",
5805 #                            "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5806 #               }
5807
5808 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5809 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5810 #               if ($^V && $^V ge 5.10.0 &&
5811 #                   defined $stat &&
5812 #                   $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5813 #
5814 #                       my $ms_val = $7;
5815 #
5816 #                       if ($ms_val =~ /^(?:0x|)0+$/i) {
5817 #                               if (WARN("PREFER_ETH_ZERO_ADDR",
5818 #                                        "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5819 #                                   $fix) {
5820 #                                       $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5821 #                               }
5822 #                       } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5823 #                               if (WARN("PREFER_ETH_BROADCAST_ADDR",
5824 #                                        "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5825 #                                   $fix) {
5826 #                                       $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5827 #                               }
5828 #                       }
5829 #               }
5830
5831 # typecasts on min/max could be min_t/max_t
5832                 if ($^V && $^V ge 5.10.0 &&
5833                     defined $stat &&
5834                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5835                         if (defined $2 || defined $7) {
5836                                 my $call = $1;
5837                                 my $cast1 = deparenthesize($2);
5838                                 my $arg1 = $3;
5839                                 my $cast2 = deparenthesize($7);
5840                                 my $arg2 = $8;
5841                                 my $cast;
5842
5843                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5844                                         $cast = "$cast1 or $cast2";
5845                                 } elsif ($cast1 ne "") {
5846                                         $cast = $cast1;
5847                                 } else {
5848                                         $cast = $cast2;
5849                                 }
5850                                 WARN("MINMAX",
5851                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5852                         }
5853                 }
5854
5855 # check usleep_range arguments
5856                 if ($^V && $^V ge 5.10.0 &&
5857                     defined $stat &&
5858                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5859                         my $min = $1;
5860                         my $max = $7;
5861                         if ($min eq $max) {
5862                                 WARN("USLEEP_RANGE",
5863                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5864                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5865                                  $min > $max) {
5866                                 WARN("USLEEP_RANGE",
5867                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5868                         }
5869                 }
5870
5871 # check for naked sscanf
5872                 if ($^V && $^V ge 5.10.0 &&
5873                     defined $stat &&
5874                     $line =~ /\bsscanf\b/ &&
5875                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5876                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5877                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5878                         my $lc = $stat =~ tr@\n@@;
5879                         $lc = $lc + $linenr;
5880                         my $stat_real = raw_line($linenr, 0);
5881                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5882                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5883                         }
5884                         WARN("NAKED_SSCANF",
5885                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5886                 }
5887
5888 # check for simple sscanf that should be kstrto<foo>
5889                 if ($^V && $^V ge 5.10.0 &&
5890                     defined $stat &&
5891                     $line =~ /\bsscanf\b/) {
5892                         my $lc = $stat =~ tr@\n@@;
5893                         $lc = $lc + $linenr;
5894                         my $stat_real = raw_line($linenr, 0);
5895                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5896                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5897                         }
5898                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5899                                 my $format = $6;
5900                                 my $count = $format =~ tr@%@%@;
5901                                 if ($count == 1 &&
5902                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5903                                         WARN("SSCANF_TO_KSTRTO",
5904                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5905                                 }
5906                         }
5907                 }
5908
5909 # check for new externs in .h files.
5910                 if ($realfile =~ /\.h$/ &&
5911                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5912                         if (CHK("AVOID_EXTERNS",
5913                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5914                             $fix) {
5915                                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5916                         }
5917                 }
5918
5919 # check for new externs in .c files.
5920                 if ($realfile =~ /\.c$/ && defined $stat &&
5921                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5922                 {
5923                         my $function_name = $1;
5924                         my $paren_space = $2;
5925
5926                         my $s = $stat;
5927                         if (defined $cond) {
5928                                 substr($s, 0, length($cond), '');
5929                         }
5930                         if ($s =~ /^\s*;/ &&
5931                             $function_name ne 'uninitialized_var')
5932                         {
5933                                 WARN("AVOID_EXTERNS",
5934                                      "externs should be avoided in .c files\n" .  $herecurr);
5935                         }
5936
5937                         if ($paren_space =~ /\n/) {
5938                                 WARN("FUNCTION_ARGUMENTS",
5939                                      "arguments for function declarations should follow identifier\n" . $herecurr);
5940                         }
5941
5942                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5943                     $stat =~ /^.\s*extern\s+/)
5944                 {
5945                         WARN("AVOID_EXTERNS",
5946                              "externs should be avoided in .c files\n" .  $herecurr);
5947                 }
5948
5949 # check for function declarations that have arguments without identifier names
5950                 if (defined $stat &&
5951                     $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
5952                     $1 ne "void") {
5953                         my $args = trim($1);
5954                         while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
5955                                 my $arg = trim($1);
5956                                 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
5957                                         WARN("FUNCTION_ARGUMENTS",
5958                                              "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
5959                                 }
5960                         }
5961                 }
5962
5963 # check for function definitions
5964                 if ($^V && $^V ge 5.10.0 &&
5965                     defined $stat &&
5966                     $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
5967                         $context_function = $1;
5968
5969 # check for multiline function definition with misplaced open brace
5970                         my $ok = 0;
5971                         my $cnt = statement_rawlines($stat);
5972                         my $herectx = $here . "\n";
5973                         for (my $n = 0; $n < $cnt; $n++) {
5974                                 my $rl = raw_line($linenr, $n);
5975                                 $herectx .=  $rl . "\n";
5976                                 $ok = 1 if ($rl =~ /^[ \+]\{/);
5977                                 $ok = 1 if ($rl =~ /\{/ && $n == 0);
5978                                 last if $rl =~ /^[ \+].*\{/;
5979                         }
5980                         if (!$ok) {
5981                                 ERROR("OPEN_BRACE",
5982                                       "open brace '{' following function definitions go on the next line\n" . $herectx);
5983                         }
5984                 }
5985
5986 # checks for new __setup's
5987                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5988                         my $name = $1;
5989
5990                         if (!grep(/$name/, @setup_docs)) {
5991                                 CHK("UNDOCUMENTED_SETUP",
5992                                     "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
5993                         }
5994                 }
5995
5996 # check for pointless casting of kmalloc return
5997                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5998                         WARN("UNNECESSARY_CASTS",
5999                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6000                 }
6001
6002 # alloc style
6003 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6004                 if ($^V && $^V ge 5.10.0 &&
6005                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6006                         CHK("ALLOC_SIZEOF_STRUCT",
6007                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6008                 }
6009
6010 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6011                 if ($^V && $^V ge 5.10.0 &&
6012                     defined $stat &&
6013                     $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6014                         my $oldfunc = $3;
6015                         my $a1 = $4;
6016                         my $a2 = $10;
6017                         my $newfunc = "kmalloc_array";
6018                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6019                         my $r1 = $a1;
6020                         my $r2 = $a2;
6021                         if ($a1 =~ /^sizeof\s*\S/) {
6022                                 $r1 = $a2;
6023                                 $r2 = $a1;
6024                         }
6025                         if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6026                             !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6027                                 my $ctx = '';
6028                                 my $herectx = $here . "\n";
6029                                 my $cnt = statement_rawlines($stat);
6030                                 for (my $n = 0; $n < $cnt; $n++) {
6031                                         $herectx .= raw_line($linenr, $n) . "\n";
6032                                 }
6033                                 if (WARN("ALLOC_WITH_MULTIPLY",
6034                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6035                                     $cnt == 1 &&
6036                                     $fix) {
6037                                         $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;
6038                                 }
6039                         }
6040                 }
6041
6042 # check for krealloc arg reuse
6043                 if ($^V && $^V ge 5.10.0 &&
6044                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6045                         WARN("KREALLOC_ARG_REUSE",
6046                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6047                 }
6048
6049 # check for alloc argument mismatch
6050                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6051                         WARN("ALLOC_ARRAY_ARGS",
6052                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6053                 }
6054
6055 # check for multiple semicolons
6056                 if ($line =~ /;\s*;\s*$/) {
6057                         if (WARN("ONE_SEMICOLON",
6058                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
6059                             $fix) {
6060                                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6061                         }
6062                 }
6063
6064 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6065                 if ($realfile !~ m@^include/uapi/@ &&
6066                     $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6067                         my $ull = "";
6068                         $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6069                         if (CHK("BIT_MACRO",
6070                                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6071                             $fix) {
6072                                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6073                         }
6074                 }
6075
6076 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6077                 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6078                         my $config = $1;
6079                         if (WARN("PREFER_IS_ENABLED",
6080                                  "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6081                             $fix) {
6082                                 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6083                         }
6084                 }
6085
6086 # check for case / default statements not preceded by break/fallthrough/switch
6087                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6088                         my $has_break = 0;
6089                         my $has_statement = 0;
6090                         my $count = 0;
6091                         my $prevline = $linenr;
6092                         while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
6093                                 $prevline--;
6094                                 my $rline = $rawlines[$prevline - 1];
6095                                 my $fline = $lines[$prevline - 1];
6096                                 last if ($fline =~ /^\@\@/);
6097                                 next if ($fline =~ /^\-/);
6098                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6099                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6100                                 next if ($fline =~ /^.[\s$;]*$/);
6101                                 $has_statement = 1;
6102                                 $count++;
6103                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|exit\s*\(\b|return\b|goto\b|continue\b)/);
6104                         }
6105                         if (!$has_break && $has_statement) {
6106                                 WARN("MISSING_BREAK",
6107                                      "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
6108                         }
6109                 }
6110
6111 # check for switch/default statements without a break;
6112                 if ($^V && $^V ge 5.10.0 &&
6113                     defined $stat &&
6114                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6115                         my $ctx = '';
6116                         my $herectx = $here . "\n";
6117                         my $cnt = statement_rawlines($stat);
6118                         for (my $n = 0; $n < $cnt; $n++) {
6119                                 $herectx .= raw_line($linenr, $n) . "\n";
6120                         }
6121                         WARN("DEFAULT_NO_BREAK",
6122                              "switch default: should use break\n" . $herectx);
6123                 }
6124
6125 # check for gcc specific __FUNCTION__
6126                 if ($line =~ /\b__FUNCTION__\b/) {
6127                         if (WARN("USE_FUNC",
6128                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
6129                             $fix) {
6130                                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6131                         }
6132                 }
6133
6134 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6135                 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6136                         ERROR("DATE_TIME",
6137                               "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6138                 }
6139
6140 # check for use of yield()
6141                 if ($line =~ /\byield\s*\(\s*\)/) {
6142                         WARN("YIELD",
6143                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
6144                 }
6145
6146 # check for comparisons against true and false
6147                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6148                         my $lead = $1;
6149                         my $arg = $2;
6150                         my $test = $3;
6151                         my $otype = $4;
6152                         my $trail = $5;
6153                         my $op = "!";
6154
6155                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6156
6157                         my $type = lc($otype);
6158                         if ($type =~ /^(?:true|false)$/) {
6159                                 if (("$test" eq "==" && "$type" eq "true") ||
6160                                     ("$test" eq "!=" && "$type" eq "false")) {
6161                                         $op = "";
6162                                 }
6163
6164                                 CHK("BOOL_COMPARISON",
6165                                     "Using comparison to $otype is error prone\n" . $herecurr);
6166
6167 ## maybe suggesting a correct construct would better
6168 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6169
6170                         }
6171                 }
6172
6173 # check for semaphores initialized locked
6174                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6175                         WARN("CONSIDER_COMPLETION",
6176                              "consider using a completion\n" . $herecurr);
6177                 }
6178
6179 # recommend kstrto* over simple_strto* and strict_strto*
6180                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6181                         WARN("CONSIDER_KSTRTO",
6182                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
6183                 }
6184
6185 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6186                 if ($line =~ /^.\s*__initcall\s*\(/) {
6187                         WARN("USE_DEVICE_INITCALL",
6188                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6189                 }
6190
6191 # check for various structs that are normally const (ops, kgdb, device_tree)
6192 # and avoid what seem like struct definitions 'struct foo {'
6193                 if ($line !~ /\bconst\b/ &&
6194                     $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6195                         WARN("CONST_STRUCT",
6196                              "struct $1 should normally be const\n" . $herecurr);
6197                 }
6198
6199 # use of NR_CPUS is usually wrong
6200 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6201                 if ($line =~ /\bNR_CPUS\b/ &&
6202                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6203                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6204                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6205                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6206                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6207                 {
6208                         WARN("NR_CPUS",
6209                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6210                 }
6211
6212 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6213                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6214                         ERROR("DEFINE_ARCH_HAS",
6215                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6216                 }
6217
6218 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6219                 if ($^V && $^V ge 5.10.0 &&
6220                     $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6221                         WARN("LIKELY_MISUSE",
6222                              "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6223                 }
6224
6225 # whine mightly about in_atomic
6226                 if ($line =~ /\bin_atomic\s*\(/) {
6227                         if ($realfile =~ m@^drivers/@) {
6228                                 ERROR("IN_ATOMIC",
6229                                       "do not use in_atomic in drivers\n" . $herecurr);
6230                         } elsif ($realfile !~ m@^kernel/@) {
6231                                 WARN("IN_ATOMIC",
6232                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6233                         }
6234                 }
6235
6236 # check for mutex_trylock_recursive usage
6237                 if ($line =~ /mutex_trylock_recursive/) {
6238                         ERROR("LOCKING",
6239                               "recursive locking is bad, do not use this ever.\n" . $herecurr);
6240                 }
6241
6242 # check for lockdep_set_novalidate_class
6243                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6244                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
6245                         if ($realfile !~ m@^kernel/lockdep@ &&
6246                             $realfile !~ m@^include/linux/lockdep@ &&
6247                             $realfile !~ m@^drivers/base/core@) {
6248                                 ERROR("LOCKDEP",
6249                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6250                         }
6251                 }
6252
6253                 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6254                     $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6255                         WARN("EXPORTED_WORLD_WRITABLE",
6256                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6257                 }
6258
6259 # Mode permission misuses where it seems decimal should be octal
6260 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6261                 if ($^V && $^V ge 5.10.0 &&
6262                     defined $stat &&
6263                     $line =~ /$mode_perms_search/) {
6264                         foreach my $entry (@mode_permission_funcs) {
6265                                 my $func = $entry->[0];
6266                                 my $arg_pos = $entry->[1];
6267
6268                                 my $lc = $stat =~ tr@\n@@;
6269                                 $lc = $lc + $linenr;
6270                                 my $stat_real = raw_line($linenr, 0);
6271                                 for (my $count = $linenr + 1; $count <= $lc; $count++) {
6272                                         $stat_real = $stat_real . "\n" . raw_line($count, 0);
6273                                 }
6274
6275                                 my $skip_args = "";
6276                                 if ($arg_pos > 1) {
6277                                         $arg_pos--;
6278                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6279                                 }
6280                                 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6281                                 if ($stat =~ /$test/) {
6282                                         my $val = $1;
6283                                         $val = $6 if ($skip_args ne "");
6284                                         if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6285                                             ($val =~ /^$Octal$/ && length($val) ne 4)) {
6286                                                 ERROR("NON_OCTAL_PERMISSIONS",
6287                                                       "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6288                                         }
6289                                         if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6290                                                 ERROR("EXPORTED_WORLD_WRITABLE",
6291                                                       "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6292                                         }
6293                                 }
6294                         }
6295                 }
6296
6297 # check for uses of S_<PERMS> that could be octal for readability
6298                 if ($line =~ /\b$mode_perms_string_search\b/) {
6299                         my $val = "";
6300                         my $oval = "";
6301                         my $to = 0;
6302                         my $curpos = 0;
6303                         my $lastpos = 0;
6304                         while ($line =~ /\b(($mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
6305                                 $curpos = pos($line);
6306                                 my $match = $2;
6307                                 my $omatch = $1;
6308                                 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
6309                                 $lastpos = $curpos;
6310                                 $to |= $mode_permission_string_types{$match};
6311                                 $val .= '\s*\|\s*' if ($val ne "");
6312                                 $val .= $match;
6313                                 $oval .= $omatch;
6314                         }
6315                         $oval =~ s/^\s*\|\s*//;
6316                         $oval =~ s/\s*\|\s*$//;
6317                         my $octal = sprintf("%04o", $to);
6318                         if (WARN("SYMBOLIC_PERMS",
6319                                  "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6320                             $fix) {
6321                                 $fixed[$fixlinenr] =~ s/$val/$octal/;
6322                         }
6323                 }
6324
6325 # validate content of MODULE_LICENSE against list from include/linux/module.h
6326                 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6327                         my $extracted_string = get_quoted_string($line, $rawline);
6328                         my $valid_licenses = qr{
6329                                                 GPL|
6330                                                 GPL\ v2|
6331                                                 GPL\ and\ additional\ rights|
6332                                                 Dual\ BSD/GPL|
6333                                                 Dual\ MIT/GPL|
6334                                                 Dual\ MPL/GPL|
6335                                                 Proprietary
6336                                         }x;
6337                         if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6338                                 WARN("MODULE_LICENSE",
6339                                      "unknown module license " . $extracted_string . "\n" . $herecurr);
6340                         }
6341                 }
6342         }
6343
6344         # If we have no input at all, then there is nothing to report on
6345         # so just keep quiet.
6346         if ($#rawlines == -1) {
6347                 exit(0);
6348         }
6349
6350         # In mailback mode only produce a report in the negative, for
6351         # things that appear to be patches.
6352         if ($mailback && ($clean == 1 || !$is_patch)) {
6353                 exit(0);
6354         }
6355
6356         # This is not a patch, and we are are in 'no-patch' mode so
6357         # just keep quiet.
6358         if (!$chk_patch && !$is_patch) {
6359                 exit(0);
6360         }
6361
6362         if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
6363                 ERROR("NOT_UNIFIED_DIFF",
6364                       "Does not appear to be a unified-diff format patch\n");
6365         }
6366         if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6367                 ERROR("MISSING_SIGN_OFF",
6368                       "Missing Signed-off-by: line(s)\n");
6369         }
6370
6371         print report_dump();
6372         if ($summary && !($clean == 1 && $quiet == 1)) {
6373                 print "$filename " if ($summary_file);
6374                 print "total: $cnt_error errors, $cnt_warn warnings, " .
6375                         (($check)? "$cnt_chk checks, " : "") .
6376                         "$cnt_lines lines checked\n";
6377         }
6378
6379         if ($quiet == 0) {
6380                 # If there were any defects found and not already fixing them
6381                 if (!$clean and !$fix) {
6382                         print << "EOM"
6383
6384 NOTE: For some of the reported defects, checkpatch may be able to
6385       mechanically convert to the typical style using --fix or --fix-inplace.
6386 EOM
6387                 }
6388                 # If there were whitespace errors which cleanpatch can fix
6389                 # then suggest that.
6390                 if ($rpt_cleaners) {
6391                         $rpt_cleaners = 0;
6392                         print << "EOM"
6393
6394 NOTE: Whitespace errors detected.
6395       You may wish to use scripts/cleanpatch or scripts/cleanfile
6396 EOM
6397                 }
6398         }
6399
6400         if ($clean == 0 && $fix &&
6401             ("@rawlines" ne "@fixed" ||
6402              $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6403                 my $newfile = $filename;
6404                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6405                 my $linecount = 0;
6406                 my $f;
6407
6408                 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6409
6410                 open($f, '>', $newfile)
6411                     or die "$P: Can't open $newfile for write\n";
6412                 foreach my $fixed_line (@fixed) {
6413                         $linecount++;
6414                         if ($file) {
6415                                 if ($linecount > 3) {
6416                                         $fixed_line =~ s/^\+//;
6417                                         print $f $fixed_line . "\n";
6418                                 }
6419                         } else {
6420                                 print $f $fixed_line . "\n";
6421                         }
6422                 }
6423                 close($f);
6424
6425                 if (!$quiet) {
6426                         print << "EOM";
6427
6428 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6429
6430 Do _NOT_ trust the results written to this file.
6431 Do _NOT_ submit these changes without inspecting them for correctness.
6432
6433 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6434 No warranties, expressed or implied...
6435 EOM
6436                 }
6437         }
6438
6439         if ($quiet == 0) {
6440                 print "\n";
6441                 if ($clean == 1) {
6442                         print "$vname has no obvious style problems and is ready for submission.\n";
6443                 } else {
6444                         print "$vname has style problems, please review.\n";
6445                 }
6446         }
6447         return $clean;
6448 }