scripts/checkpatch.pl

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