scripts/checkpatch.pl

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