scripts/checkpatch.pl

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