scripts/checkpatch.pl

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