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