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