scripts/checkpatch.pl

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