git.karo-electronics.de Git - karo-tx-linux.git/blob

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