scripts/checkpatch.pl

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