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? (a single leading tab, then return;)
3480                 if ($sline =~ /^\+\treturn\s*;\s*$/ &&
3481                     $prevline =~ /^\+/) {
3482                         WARN("RETURN_VOID",
3483                              "void function return statements are not generally useful\n" . $herecurr);
3484                 }
3485
3486 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3487                 if ($^V && $^V ge 5.10.0 &&
3488                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
3489                         my $openparens = $1;
3490                         my $count = $openparens =~ tr@\(@\(@;
3491                         my $msg = "";
3492                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3493                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
3494                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
3495                                 WARN("UNNECESSARY_PARENTHESES",
3496                                      "Unnecessary parentheses$msg\n" . $herecurr);
3497                         }
3498                 }
3499
3500 # Return of what appears to be an errno should normally be -'ve
3501                 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3502                         my $name = $1;
3503                         if ($name ne 'EOF' && $name ne 'ERROR') {
3504                                 WARN("USE_NEGATIVE_ERRNO",
3505                                      "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3506                         }
3507                 }
3508
3509 # Need a space before open parenthesis after if, while etc
3510                 if ($line =~ /\b(if|while|for|switch)\(/) {
3511                         if (ERROR("SPACING",
3512                                   "space required before the open parenthesis '('\n" . $herecurr) &&
3513                             $fix) {
3514                                 $fixed[$linenr - 1] =~
3515                                     s/\b(if|while|for|switch)\(/$1 \(/;
3516                         }
3517                 }
3518
3519 # Check for illegal assignment in if conditional -- and check for trailing
3520 # statements after the conditional.
3521                 if ($line =~ /do\s*(?!{)/) {
3522                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3523                                 ctx_statement_block($linenr, $realcnt, 0)
3524                                         if (!defined $stat);
3525                         my ($stat_next) = ctx_statement_block($line_nr_next,
3526                                                 $remain_next, $off_next);
3527                         $stat_next =~ s/\n./\n /g;
3528                         ##print "stat<$stat> stat_next<$stat_next>\n";
3529
3530                         if ($stat_next =~ /^\s*while\b/) {
3531                                 # If the statement carries leading newlines,
3532                                 # then count those as offsets.
3533                                 my ($whitespace) =
3534                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3535                                 my $offset =
3536                                         statement_rawlines($whitespace) - 1;
3537
3538                                 $suppress_whiletrailers{$line_nr_next +
3539                                                                 $offset} = 1;
3540                         }
3541                 }
3542                 if (!defined $suppress_whiletrailers{$linenr} &&
3543                     defined($stat) && defined($cond) &&
3544                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3545                         my ($s, $c) = ($stat, $cond);
3546
3547                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3548                                 ERROR("ASSIGN_IN_IF",
3549                                       "do not use assignment in if condition\n" . $herecurr);
3550                         }
3551
3552                         # Find out what is on the end of the line after the
3553                         # conditional.
3554                         substr($s, 0, length($c), '');
3555                         $s =~ s/\n.*//g;
3556                         $s =~ s/$;//g;  # Remove any comments
3557                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3558                             $c !~ /}\s*while\s*/)
3559                         {
3560                                 # Find out how long the conditional actually is.
3561                                 my @newlines = ($c =~ /\n/gs);
3562                                 my $cond_lines = 1 + $#newlines;
3563                                 my $stat_real = '';
3564
3565                                 $stat_real = raw_line($linenr, $cond_lines)
3566                                                         . "\n" if ($cond_lines);
3567                                 if (defined($stat_real) && $cond_lines > 1) {
3568                                         $stat_real = "[...]\n$stat_real";
3569                                 }
3570
3571                                 ERROR("TRAILING_STATEMENTS",
3572                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
3573                         }
3574                 }
3575
3576 # Check for bitwise tests written as boolean
3577                 if ($line =~ /
3578                         (?:
3579                                 (?:\[|\(|\&\&|\|\|)
3580                                 \s*0[xX][0-9]+\s*
3581                                 (?:\&\&|\|\|)
3582                         |
3583                                 (?:\&\&|\|\|)
3584                                 \s*0[xX][0-9]+\s*
3585                                 (?:\&\&|\|\||\)|\])
3586                         )/x)
3587                 {
3588                         WARN("HEXADECIMAL_BOOLEAN_TEST",
3589                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3590                 }
3591
3592 # if and else should not have general statements after it
3593                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3594                         my $s = $1;
3595                         $s =~ s/$;//g;  # Remove any comments
3596                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3597                                 ERROR("TRAILING_STATEMENTS",
3598                                       "trailing statements should be on next line\n" . $herecurr);
3599                         }
3600                 }
3601 # if should not continue a brace
3602                 if ($line =~ /}\s*if\b/) {
3603                         ERROR("TRAILING_STATEMENTS",
3604                               "trailing statements should be on next line\n" .
3605                                 $herecurr);
3606                 }
3607 # case and default should not have general statements after them
3608                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3609                     $line !~ /\G(?:
3610                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3611                         \s*return\s+
3612                     )/xg)
3613                 {
3614                         ERROR("TRAILING_STATEMENTS",
3615                               "trailing statements should be on next line\n" . $herecurr);
3616                 }
3617
3618                 # Check for }<nl>else {, these must be at the same
3619                 # indent level to be relevant to each other.
3620                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3621                                                 $previndent == $indent) {
3622                         ERROR("ELSE_AFTER_BRACE",
3623                               "else should follow close brace '}'\n" . $hereprev);
3624                 }
3625
3626                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3627                                                 $previndent == $indent) {
3628                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3629
3630                         # Find out what is on the end of the line after the
3631                         # conditional.
3632                         substr($s, 0, length($c), '');
3633                         $s =~ s/\n.*//g;
3634
3635                         if ($s =~ /^\s*;/) {
3636                                 ERROR("WHILE_AFTER_BRACE",
3637                                       "while should follow close brace '}'\n" . $hereprev);
3638                         }
3639                 }
3640
3641 #Specific variable tests
3642                 while ($line =~ m{($Constant|$Lval)}g) {
3643                         my $var = $1;
3644
3645 #gcc binary extension
3646                         if ($var =~ /^$Binary$/) {
3647                                 if (WARN("GCC_BINARY_CONSTANT",
3648                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3649                                     $fix) {
3650                                         my $hexval = sprintf("0x%x", oct($var));
3651                                         $fixed[$linenr - 1] =~
3652                                             s/\b$var\b/$hexval/;
3653                                 }
3654                         }
3655
3656 #CamelCase
3657                         if ($var !~ /^$Constant$/ &&
3658                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3659 #Ignore Page<foo> variants
3660                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3661 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3662                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3663                                 while ($var =~ m{($Ident)}g) {
3664                                         my $word = $1;
3665                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3666                                         if ($check) {
3667                                                 seed_camelcase_includes();
3668                                                 if (!$file && !$camelcase_file_seeded) {
3669                                                         seed_camelcase_file($realfile);
3670                                                         $camelcase_file_seeded = 1;
3671                                                 }
3672                                         }
3673                                         if (!defined $camelcase{$word}) {
3674                                                 $camelcase{$word} = 1;
3675                                                 CHK("CAMELCASE",
3676                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
3677                                         }
3678                                 }
3679                         }
3680                 }
3681
3682 #no spaces allowed after \ in define
3683                 if ($line =~ /\#\s*define.*\\\s+$/) {
3684                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3685                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3686                             $fix) {
3687                                 $fixed[$linenr - 1] =~ s/\s+$//;
3688                         }
3689                 }
3690
3691 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3692                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3693                         my $file = "$1.h";
3694                         my $checkfile = "include/linux/$file";
3695                         if (-f "$root/$checkfile" &&
3696                             $realfile ne $checkfile &&
3697                             $1 !~ /$allowed_asm_includes/)
3698                         {
3699                                 if ($realfile =~ m{^arch/}) {
3700                                         CHK("ARCH_INCLUDE_LINUX",
3701                                             "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3702                                 } else {
3703                                         WARN("INCLUDE_LINUX",
3704                                              "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3705                                 }
3706                         }
3707                 }
3708
3709 # multi-statement macros should be enclosed in a do while loop, grab the
3710 # first statement and ensure its the whole macro if its not enclosed
3711 # in a known good container
3712                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3713                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3714                         my $ln = $linenr;
3715                         my $cnt = $realcnt;
3716                         my ($off, $dstat, $dcond, $rest);
3717                         my $ctx = '';
3718                         ($dstat, $dcond, $ln, $cnt, $off) =
3719                                 ctx_statement_block($linenr, $realcnt, 0);
3720                         $ctx = $dstat;
3721                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3722                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3723
3724                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3725                         $dstat =~ s/$;//g;
3726                         $dstat =~ s/\\\n.//g;
3727                         $dstat =~ s/^\s*//s;
3728                         $dstat =~ s/\s*$//s;
3729
3730                         # Flatten any parentheses and braces
3731                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3732                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
3733                                $dstat =~ s/\[[^\[\]]*\]/1/)
3734                         {
3735                         }
3736
3737                         # Flatten any obvious string concatentation.
3738                         while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3739                                $dstat =~ s/$Ident\s*("X*")/$1/)
3740                         {
3741                         }
3742
3743                         my $exceptions = qr{
3744                                 $Declare|
3745                                 module_param_named|
3746                                 MODULE_PARM_DESC|
3747                                 DECLARE_PER_CPU|
3748                                 DEFINE_PER_CPU|
3749                                 __typeof__\(|
3750                                 union|
3751                                 struct|
3752                                 \.$Ident\s*=\s*|
3753                                 ^\"|\"$
3754                         }x;
3755                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3756                         if ($dstat ne '' &&
3757                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
3758                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
3759                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3760                             $dstat !~ /^'X'$/ &&                                        # character constants
3761                             $dstat !~ /$exceptions/ &&
3762                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
3763                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
3764                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
3765                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
3766                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
3767                             $dstat !~ /^do\s*{/ &&                                      # do {...
3768                             $dstat !~ /^\({/ &&                                         # ({...
3769                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3770                         {
3771                                 $ctx =~ s/\n*$//;
3772                                 my $herectx = $here . "\n";
3773                                 my $cnt = statement_rawlines($ctx);
3774
3775                                 for (my $n = 0; $n < $cnt; $n++) {
3776                                         $herectx .= raw_line($linenr, $n) . "\n";
3777                                 }
3778
3779                                 if ($dstat =~ /;/) {
3780                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3781                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3782                                 } else {
3783                                         ERROR("COMPLEX_MACRO",
3784                                               "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3785                                 }
3786                         }
3787
3788 # check for line continuations outside of #defines, preprocessor #, and asm
3789
3790                 } else {
3791                         if ($prevline !~ /^..*\\$/ &&
3792                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
3793                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
3794                             $line =~ /^\+.*\\$/) {
3795                                 WARN("LINE_CONTINUATIONS",
3796                                      "Avoid unnecessary line continuations\n" . $herecurr);
3797                         }
3798                 }
3799
3800 # do {} while (0) macro tests:
3801 # single-statement macros do not need to be enclosed in do while (0) loop,
3802 # macro should not end with a semicolon
3803                 if ($^V && $^V ge 5.10.0 &&
3804                     $realfile !~ m@/vmlinux.lds.h$@ &&
3805                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3806                         my $ln = $linenr;
3807                         my $cnt = $realcnt;
3808                         my ($off, $dstat, $dcond, $rest);
3809                         my $ctx = '';
3810                         ($dstat, $dcond, $ln, $cnt, $off) =
3811                                 ctx_statement_block($linenr, $realcnt, 0);
3812                         $ctx = $dstat;
3813
3814                         $dstat =~ s/\\\n.//g;
3815
3816                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3817                                 my $stmts = $2;
3818                                 my $semis = $3;
3819
3820                                 $ctx =~ s/\n*$//;
3821                                 my $cnt = statement_rawlines($ctx);
3822                                 my $herectx = $here . "\n";
3823
3824                                 for (my $n = 0; $n < $cnt; $n++) {
3825                                         $herectx .= raw_line($linenr, $n) . "\n";
3826                                 }
3827
3828                                 if (($stmts =~ tr/;/;/) == 1 &&
3829                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
3830                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3831                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3832                                 }
3833                                 if (defined $semis && $semis ne "") {
3834                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3835                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3836                                 }
3837                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
3838                                 $ctx =~ s/\n*$//;
3839                                 my $cnt = statement_rawlines($ctx);
3840                                 my $herectx = $here . "\n";
3841
3842                                 for (my $n = 0; $n < $cnt; $n++) {
3843                                         $herectx .= raw_line($linenr, $n) . "\n";
3844                                 }
3845
3846                                 WARN("TRAILING_SEMICOLON",
3847                                      "macros should not use a trailing semicolon\n" . "$herectx");
3848                         }
3849                 }
3850
3851 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3852 # all assignments may have only one of the following with an assignment:
3853 #       .
3854 #       ALIGN(...)
3855 #       VMLINUX_SYMBOL(...)
3856                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3857                         WARN("MISSING_VMLINUX_SYMBOL",
3858                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3859                 }
3860
3861 # check for redundant bracing round if etc
3862                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3863                         my ($level, $endln, @chunks) =
3864                                 ctx_statement_full($linenr, $realcnt, 1);
3865                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3866                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3867                         if ($#chunks > 0 && $level == 0) {
3868                                 my @allowed = ();
3869                                 my $allow = 0;
3870                                 my $seen = 0;
3871                                 my $herectx = $here . "\n";
3872                                 my $ln = $linenr - 1;
3873                                 for my $chunk (@chunks) {
3874                                         my ($cond, $block) = @{$chunk};
3875
3876                                         # If the condition carries leading newlines, then count those as offsets.
3877                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3878                                         my $offset = statement_rawlines($whitespace) - 1;
3879
3880                                         $allowed[$allow] = 0;
3881                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3882
3883                                         # We have looked at and allowed this specific line.
3884                                         $suppress_ifbraces{$ln + $offset} = 1;
3885
3886                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3887                                         $ln += statement_rawlines($block) - 1;
3888
3889                                         substr($block, 0, length($cond), '');
3890
3891                                         $seen++ if ($block =~ /^\s*{/);
3892
3893                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3894                                         if (statement_lines($cond) > 1) {
3895                                                 #print "APW: ALLOWED: cond<$cond>\n";
3896                                                 $allowed[$allow] = 1;
3897                                         }
3898                                         if ($block =~/\b(?:if|for|while)\b/) {
3899                                                 #print "APW: ALLOWED: block<$block>\n";
3900                                                 $allowed[$allow] = 1;
3901                                         }
3902                                         if (statement_block_size($block) > 1) {
3903                                                 #print "APW: ALLOWED: lines block<$block>\n";
3904                                                 $allowed[$allow] = 1;
3905                                         }
3906                                         $allow++;
3907                                 }
3908                                 if ($seen) {
3909                                         my $sum_allowed = 0;
3910                                         foreach (@allowed) {
3911                                                 $sum_allowed += $_;
3912                                         }
3913                                         if ($sum_allowed == 0) {
3914                                                 WARN("BRACES",
3915                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
3916                                         } elsif ($sum_allowed != $allow &&
3917                                                  $seen != $allow) {
3918                                                 CHK("BRACES",
3919                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
3920                                         }
3921                                 }
3922                         }
3923                 }
3924                 if (!defined $suppress_ifbraces{$linenr - 1} &&
3925                                         $line =~ /\b(if|while|for|else)\b/) {
3926                         my $allowed = 0;
3927
3928                         # Check the pre-context.
3929                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3930                                 #print "APW: ALLOWED: pre<$1>\n";
3931                                 $allowed = 1;
3932                         }
3933
3934                         my ($level, $endln, @chunks) =
3935                                 ctx_statement_full($linenr, $realcnt, $-[0]);
3936
3937                         # Check the condition.
3938                         my ($cond, $block) = @{$chunks[0]};
3939                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3940                         if (defined $cond) {
3941                                 substr($block, 0, length($cond), '');
3942                         }
3943                         if (statement_lines($cond) > 1) {
3944                                 #print "APW: ALLOWED: cond<$cond>\n";
3945                                 $allowed = 1;
3946                         }
3947                         if ($block =~/\b(?:if|for|while)\b/) {
3948                                 #print "APW: ALLOWED: block<$block>\n";
3949                                 $allowed = 1;
3950                         }
3951                         if (statement_block_size($block) > 1) {
3952                                 #print "APW: ALLOWED: lines block<$block>\n";
3953                                 $allowed = 1;
3954                         }
3955                         # Check the post-context.
3956                         if (defined $chunks[1]) {
3957                                 my ($cond, $block) = @{$chunks[1]};
3958                                 if (defined $cond) {
3959                                         substr($block, 0, length($cond), '');
3960                                 }
3961                                 if ($block =~ /^\s*\{/) {
3962                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
3963                                         $allowed = 1;
3964                                 }
3965                         }
3966                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3967                                 my $herectx = $here . "\n";
3968                                 my $cnt = statement_rawlines($block);
3969
3970                                 for (my $n = 0; $n < $cnt; $n++) {
3971                                         $herectx .= raw_line($linenr, $n) . "\n";
3972                                 }
3973
3974                                 WARN("BRACES",
3975                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
3976                         }
3977                 }
3978
3979 # check for unnecessary blank lines around braces
3980                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
3981                         CHK("BRACES",
3982                             "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3983                 }
3984                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
3985                         CHK("BRACES",
3986                             "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3987                 }
3988
3989 # no volatiles please
3990                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3991                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3992                         WARN("VOLATILE",
3993                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3994                 }
3995
3996 # warn about #if 0
3997                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3998                         CHK("REDUNDANT_CODE",
3999                             "if this code is redundant consider removing it\n" .
4000                                 $herecurr);
4001                 }
4002
4003 # check for needless "if (<foo>) fn(<foo>)" uses
4004                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4005                         my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4006                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4007                                 WARN('NEEDLESS_IF',
4008                                      "$1(NULL) is safe this check is probably not required\n" . $hereprev);
4009                         }
4010                 }
4011
4012 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4013                 if ($line =~ /(\b$InitAttribute\b)/) {
4014                         my $attr = $1;
4015                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4016                                 my $ptr = $1;
4017                                 my $var = $2;
4018                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4019                                       ERROR("MISPLACED_INIT",
4020                                             "$attr should be placed after $var\n" . $herecurr)) ||
4021                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4022                                       WARN("MISPLACED_INIT",
4023                                            "$attr should be placed after $var\n" . $herecurr))) &&
4024                                     $fix) {
4025                                         $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;
4026                                 }
4027                         }
4028                 }
4029
4030 # check for $InitAttributeData (ie: __initdata) with const
4031                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4032                         my $attr = $1;
4033                         $attr =~ /($InitAttributePrefix)(.*)/;
4034                         my $attr_prefix = $1;
4035                         my $attr_type = $2;
4036                         if (ERROR("INIT_ATTRIBUTE",
4037                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4038                             $fix) {
4039                                 $fixed[$linenr - 1] =~
4040                                     s/$InitAttributeData/${attr_prefix}initconst/;
4041                         }
4042                 }
4043
4044 # check for $InitAttributeConst (ie: __initconst) without const
4045                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4046                         my $attr = $1;
4047                         if (ERROR("INIT_ATTRIBUTE",
4048                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
4049                             $fix) {
4050                                 my $lead = $fixed[$linenr - 1] =~
4051                                     /(^\+\s*(?:static\s+))/;
4052                                 $lead = rtrim($1);
4053                                 $lead = "$lead " if ($lead !~ /^\+$/);
4054                                 $lead = "${lead}const ";
4055                                 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
4056                         }
4057                 }
4058
4059 # don't use __constant_<foo> functions outside of include/uapi/
4060                 if ($realfile !~ m@^include/uapi/@ &&
4061                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4062                         my $constant_func = $1;
4063                         my $func = $constant_func;
4064                         $func =~ s/^__constant_//;
4065                         if (WARN("CONSTANT_CONVERSION",
4066                                  "$constant_func should be $func\n" . $herecurr) &&
4067                             $fix) {
4068                                 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
4069                         }
4070                 }
4071
4072 # prefer usleep_range over udelay
4073                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4074                         my $delay = $1;
4075                         # ignore udelay's < 10, however
4076                         if (! ($delay < 10) ) {
4077                                 CHK("USLEEP_RANGE",
4078                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4079                         }
4080                         if ($delay > 2000) {
4081                                 WARN("LONG_UDELAY",
4082                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4083                         }
4084                 }
4085
4086 # warn about unexpectedly long msleep's
4087                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4088                         if ($1 < 20) {
4089                                 WARN("MSLEEP",
4090                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4091                         }
4092                 }
4093
4094 # check for comparisons of jiffies
4095                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4096                         WARN("JIFFIES_COMPARISON",
4097                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4098                 }
4099
4100 # check for comparisons of get_jiffies_64()
4101                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4102                         WARN("JIFFIES_COMPARISON",
4103                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4104                 }
4105
4106 # warn about #ifdefs in C files
4107 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4108 #                       print "#ifdef in C files should be avoided\n";
4109 #                       print "$herecurr";
4110 #                       $clean = 0;
4111 #               }
4112
4113 # warn about spacing in #ifdefs
4114                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4115                         if (ERROR("SPACING",
4116                                   "exactly one space required after that #$1\n" . $herecurr) &&
4117                             $fix) {
4118                                 $fixed[$linenr - 1] =~
4119                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4120                         }
4121
4122                 }
4123
4124 # check for spinlock_t definitions without a comment.
4125                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4126                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4127                         my $which = $1;
4128                         if (!ctx_has_comment($first_line, $linenr)) {
4129                                 CHK("UNCOMMENTED_DEFINITION",
4130                                     "$1 definition without comment\n" . $herecurr);
4131                         }
4132                 }
4133 # check for memory barriers without a comment.
4134                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4135                         if (!ctx_has_comment($first_line, $linenr)) {
4136                                 WARN("MEMORY_BARRIER",
4137                                      "memory barrier without comment\n" . $herecurr);
4138                         }
4139                 }
4140 # check of hardware specific defines
4141                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4142                         CHK("ARCH_DEFINES",
4143                             "architecture specific defines should be avoided\n" .  $herecurr);
4144                 }
4145
4146 # Check that the storage class is at the beginning of a declaration
4147                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4148                         WARN("STORAGE_CLASS",
4149                              "storage class should be at the beginning of the declaration\n" . $herecurr)
4150                 }
4151
4152 # check the location of the inline attribute, that it is between
4153 # storage class and type.
4154                 if ($line =~ /\b$Type\s+$Inline\b/ ||
4155                     $line =~ /\b$Inline\s+$Storage\b/) {
4156                         ERROR("INLINE_LOCATION",
4157                               "inline keyword should sit between storage class and type\n" . $herecurr);
4158                 }
4159
4160 # Check for __inline__ and __inline, prefer inline
4161                 if ($realfile !~ m@\binclude/uapi/@ &&
4162                     $line =~ /\b(__inline__|__inline)\b/) {
4163                         if (WARN("INLINE",
4164                                  "plain inline is preferred over $1\n" . $herecurr) &&
4165                             $fix) {
4166                                 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4167
4168                         }
4169                 }
4170
4171 # Check for __attribute__ packed, prefer __packed
4172                 if ($realfile !~ m@\binclude/uapi/@ &&
4173                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4174                         WARN("PREFER_PACKED",
4175                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4176                 }
4177
4178 # Check for __attribute__ aligned, prefer __aligned
4179                 if ($realfile !~ m@\binclude/uapi/@ &&
4180                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4181                         WARN("PREFER_ALIGNED",
4182                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4183                 }
4184
4185 # Check for __attribute__ format(printf, prefer __printf
4186                 if ($realfile !~ m@\binclude/uapi/@ &&
4187                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4188                         if (WARN("PREFER_PRINTF",
4189                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4190                             $fix) {
4191                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4192
4193                         }
4194                 }
4195
4196 # Check for __attribute__ format(scanf, prefer __scanf
4197                 if ($realfile !~ m@\binclude/uapi/@ &&
4198                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4199                         if (WARN("PREFER_SCANF",
4200                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4201                             $fix) {
4202                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4203                         }
4204                 }
4205
4206 # check for sizeof(&)
4207                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4208                         WARN("SIZEOF_ADDRESS",
4209                              "sizeof(& should be avoided\n" . $herecurr);
4210                 }
4211
4212 # check for sizeof without parenthesis
4213                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4214                         if (WARN("SIZEOF_PARENTHESIS",
4215                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4216                             $fix) {
4217                                 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4218                         }
4219                 }
4220
4221 # check for line continuations in quoted strings with odd counts of "
4222                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4223                         WARN("LINE_CONTINUATIONS",
4224                              "Avoid line continuations in quoted strings\n" . $herecurr);
4225                 }
4226
4227 # check for struct spinlock declarations
4228                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4229                         WARN("USE_SPINLOCK_T",
4230                              "struct spinlock should be spinlock_t\n" . $herecurr);
4231                 }
4232
4233 # check for seq_printf uses that could be seq_puts
4234                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4235                         my $fmt = get_quoted_string($line, $rawline);
4236                         if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4237                                 if (WARN("PREFER_SEQ_PUTS",
4238                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4239                                     $fix) {
4240                                         $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4241                                 }
4242                         }
4243                 }
4244
4245 # Check for misused memsets
4246                 if ($^V && $^V ge 5.10.0 &&
4247                     defined $stat &&
4248                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4249
4250                         my $ms_addr = $2;
4251                         my $ms_val = $7;
4252                         my $ms_size = $12;
4253
4254                         if ($ms_size =~ /^(0x|)0$/i) {
4255                                 ERROR("MEMSET",
4256                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4257                         } elsif ($ms_size =~ /^(0x|)1$/i) {
4258                                 WARN("MEMSET",
4259                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4260                         }
4261                 }
4262
4263 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4264                 if ($^V && $^V ge 5.10.0 &&
4265                     $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4266                         if (WARN("PREFER_ETHER_ADDR_COPY",
4267                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4268                             $fix) {
4269                                 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4270                         }
4271                 }
4272
4273 # typecasts on min/max could be min_t/max_t
4274                 if ($^V && $^V ge 5.10.0 &&
4275                     defined $stat &&
4276                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4277                         if (defined $2 || defined $7) {
4278                                 my $call = $1;
4279                                 my $cast1 = deparenthesize($2);
4280                                 my $arg1 = $3;
4281                                 my $cast2 = deparenthesize($7);
4282                                 my $arg2 = $8;
4283                                 my $cast;
4284
4285                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4286                                         $cast = "$cast1 or $cast2";
4287                                 } elsif ($cast1 ne "") {
4288                                         $cast = $cast1;
4289                                 } else {
4290                                         $cast = $cast2;
4291                                 }
4292                                 WARN("MINMAX",
4293                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4294                         }
4295                 }
4296
4297 # check usleep_range arguments
4298                 if ($^V && $^V ge 5.10.0 &&
4299                     defined $stat &&
4300                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4301                         my $min = $1;
4302                         my $max = $7;
4303                         if ($min eq $max) {
4304                                 WARN("USLEEP_RANGE",
4305                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4306                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4307                                  $min > $max) {
4308                                 WARN("USLEEP_RANGE",
4309                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4310                         }
4311                 }
4312
4313 # check for naked sscanf
4314                 if ($^V && $^V ge 5.10.0 &&
4315                     defined $stat &&
4316                     $line =~ /\bsscanf\b/ &&
4317                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4318                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4319                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4320                         my $lc = $stat =~ tr@\n@@;
4321                         $lc = $lc + $linenr;
4322                         my $stat_real = raw_line($linenr, 0);
4323                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
4324                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4325                         }
4326                         WARN("NAKED_SSCANF",
4327                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4328                 }
4329
4330 # check for simple sscanf that should be kstrto<foo>
4331                 if ($^V && $^V ge 5.10.0 &&
4332                     defined $stat &&
4333                     $line =~ /\bsscanf\b/) {
4334                         my $lc = $stat =~ tr@\n@@;
4335                         $lc = $lc + $linenr;
4336                         my $stat_real = raw_line($linenr, 0);
4337                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
4338                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4339                         }
4340                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
4341                                 my $format = $6;
4342                                 my $count = $format =~ tr@%@%@;
4343                                 if ($count == 1 &&
4344                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
4345                                         WARN("SSCANF_TO_KSTRTO",
4346                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4347                                 }
4348                         }
4349                 }
4350
4351 # check for new externs in .h files.
4352                 if ($realfile =~ /\.h$/ &&
4353                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4354                         if (CHK("AVOID_EXTERNS",
4355                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4356                             $fix) {
4357                                 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4358                         }
4359                 }
4360
4361 # check for new externs in .c files.
4362                 if ($realfile =~ /\.c$/ && defined $stat &&
4363                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4364                 {
4365                         my $function_name = $1;
4366                         my $paren_space = $2;
4367
4368                         my $s = $stat;
4369                         if (defined $cond) {
4370                                 substr($s, 0, length($cond), '');
4371                         }
4372                         if ($s =~ /^\s*;/ &&
4373                             $function_name ne 'uninitialized_var')
4374                         {
4375                                 WARN("AVOID_EXTERNS",
4376                                      "externs should be avoided in .c files\n" .  $herecurr);
4377                         }
4378
4379                         if ($paren_space =~ /\n/) {
4380                                 WARN("FUNCTION_ARGUMENTS",
4381                                      "arguments for function declarations should follow identifier\n" . $herecurr);
4382                         }
4383
4384                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4385                     $stat =~ /^.\s*extern\s+/)
4386                 {
4387                         WARN("AVOID_EXTERNS",
4388                              "externs should be avoided in .c files\n" .  $herecurr);
4389                 }
4390
4391 # checks for new __setup's
4392                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4393                         my $name = $1;
4394
4395                         if (!grep(/$name/, @setup_docs)) {
4396                                 CHK("UNDOCUMENTED_SETUP",
4397                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4398                         }
4399                 }
4400
4401 # check for pointless casting of kmalloc return
4402                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4403                         WARN("UNNECESSARY_CASTS",
4404                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4405                 }
4406
4407 # alloc style
4408 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4409                 if ($^V && $^V ge 5.10.0 &&
4410                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4411                         CHK("ALLOC_SIZEOF_STRUCT",
4412                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4413                 }
4414
4415 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4416                 if ($^V && $^V ge 5.10.0 &&
4417                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/) {
4418                         my $oldfunc = $3;
4419                         my $a1 = $4;
4420                         my $a2 = $10;
4421                         my $newfunc = "kmalloc_array";
4422                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4423                         if ($a1 =~ /^sizeof\s*\S/ || $a2 =~ /^sizeof\s*\S/) {
4424                                 if (WARN("ALLOC_WITH_MULTIPLY",
4425                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4426                                     $fix) {
4427                                         my $r1 = $a1;
4428                                         my $r2 = $a2;
4429                                         if ($a1 =~ /^sizeof\s*\S/) {
4430                                                 $r1 = $a2;
4431                                                 $r2 = $a1;
4432                                         }
4433                                         $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;
4434
4435                                 }
4436                         }
4437                 }
4438
4439 # check for krealloc arg reuse
4440                 if ($^V && $^V ge 5.10.0 &&
4441                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4442                         WARN("KREALLOC_ARG_REUSE",
4443                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4444                 }
4445
4446 # check for alloc argument mismatch
4447                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4448                         WARN("ALLOC_ARRAY_ARGS",
4449                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4450                 }
4451
4452 # check for multiple semicolons
4453                 if ($line =~ /;\s*;\s*$/) {
4454                         if (WARN("ONE_SEMICOLON",
4455                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
4456                             $fix) {
4457                                 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4458                         }
4459                 }
4460
4461 # check for case / default statements not preceeded by break/fallthrough/switch
4462                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4463                         my $has_break = 0;
4464                         my $has_statement = 0;
4465                         my $count = 0;
4466                         my $prevline = $linenr;
4467                         while ($prevline > 1 && $count < 3 && !$has_break) {
4468                                 $prevline--;
4469                                 my $rline = $rawlines[$prevline - 1];
4470                                 my $fline = $lines[$prevline - 1];
4471                                 last if ($fline =~ /^\@\@/);
4472                                 next if ($fline =~ /^\-/);
4473                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4474                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4475                                 next if ($fline =~ /^.[\s$;]*$/);
4476                                 $has_statement = 1;
4477                                 $count++;
4478                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4479                         }
4480                         if (!$has_break && $has_statement) {
4481                                 WARN("MISSING_BREAK",
4482                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4483                         }
4484                 }
4485
4486 # check for switch/default statements without a break;
4487                 if ($^V && $^V ge 5.10.0 &&
4488                     defined $stat &&
4489                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4490                         my $ctx = '';
4491                         my $herectx = $here . "\n";
4492                         my $cnt = statement_rawlines($stat);
4493                         for (my $n = 0; $n < $cnt; $n++) {
4494                                 $herectx .= raw_line($linenr, $n) . "\n";
4495                         }
4496                         WARN("DEFAULT_NO_BREAK",
4497                              "switch default: should use break\n" . $herectx);
4498                 }
4499
4500 # check for gcc specific __FUNCTION__
4501                 if ($line =~ /\b__FUNCTION__\b/) {
4502                         if (WARN("USE_FUNC",
4503                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
4504                             $fix) {
4505                                 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4506                         }
4507                 }
4508
4509 # check for use of yield()
4510                 if ($line =~ /\byield\s*\(\s*\)/) {
4511                         WARN("YIELD",
4512                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
4513                 }
4514
4515 # check for comparisons against true and false
4516                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4517                         my $lead = $1;
4518                         my $arg = $2;
4519                         my $test = $3;
4520                         my $otype = $4;
4521                         my $trail = $5;
4522                         my $op = "!";
4523
4524                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4525
4526                         my $type = lc($otype);
4527                         if ($type =~ /^(?:true|false)$/) {
4528                                 if (("$test" eq "==" && "$type" eq "true") ||
4529                                     ("$test" eq "!=" && "$type" eq "false")) {
4530                                         $op = "";
4531                                 }
4532
4533                                 CHK("BOOL_COMPARISON",
4534                                     "Using comparison to $otype is error prone\n" . $herecurr);
4535
4536 ## maybe suggesting a correct construct would better
4537 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4538
4539                         }
4540                 }
4541
4542 # check for semaphores initialized locked
4543                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4544                         WARN("CONSIDER_COMPLETION",
4545                              "consider using a completion\n" . $herecurr);
4546                 }
4547
4548 # recommend kstrto* over simple_strto* and strict_strto*
4549                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4550                         WARN("CONSIDER_KSTRTO",
4551                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
4552                 }
4553
4554 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
4555                 if ($line =~ /^.\s*__initcall\s*\(/) {
4556                         WARN("USE_DEVICE_INITCALL",
4557                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
4558                 }
4559
4560 # check for various ops structs, ensure they are const.
4561                 my $struct_ops = qr{acpi_dock_ops|
4562                                 address_space_operations|
4563                                 backlight_ops|
4564                                 block_device_operations|
4565                                 dentry_operations|
4566                                 dev_pm_ops|
4567                                 dma_map_ops|
4568                                 extent_io_ops|
4569                                 file_lock_operations|
4570                                 file_operations|
4571                                 hv_ops|
4572                                 ide_dma_ops|
4573                                 intel_dvo_dev_ops|
4574                                 item_operations|
4575                                 iwl_ops|
4576                                 kgdb_arch|
4577                                 kgdb_io|
4578                                 kset_uevent_ops|
4579                                 lock_manager_operations|
4580                                 microcode_ops|
4581                                 mtrr_ops|
4582                                 neigh_ops|
4583                                 nlmsvc_binding|
4584                                 pci_raw_ops|
4585                                 pipe_buf_operations|
4586                                 platform_hibernation_ops|
4587                                 platform_suspend_ops|
4588                                 proto_ops|
4589                                 rpc_pipe_ops|
4590                                 seq_operations|
4591                                 snd_ac97_build_ops|
4592                                 soc_pcmcia_socket_ops|
4593                                 stacktrace_ops|
4594                                 sysfs_ops|
4595                                 tty_operations|
4596                                 usb_mon_operations|
4597                                 wd_ops}x;
4598                 if ($line !~ /\bconst\b/ &&
4599                     $line =~ /\bstruct\s+($struct_ops)\b/) {
4600                         WARN("CONST_STRUCT",
4601                              "struct $1 should normally be const\n" .
4602                                 $herecurr);
4603                 }
4604
4605 # use of NR_CPUS is usually wrong
4606 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4607                 if ($line =~ /\bNR_CPUS\b/ &&
4608                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4609                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4610                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4611                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4612                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4613                 {
4614                         WARN("NR_CPUS",
4615                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4616                 }
4617
4618 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4619                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4620                         ERROR("DEFINE_ARCH_HAS",
4621                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4622                 }
4623
4624 # check for %L{u,d,i} in strings
4625                 my $string;
4626                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4627                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4628                         $string =~ s/%%/__/g;
4629                         if ($string =~ /(?<!%)%L[udi]/) {
4630                                 WARN("PRINTF_L",
4631                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4632                                 last;
4633                         }
4634                 }
4635
4636 # whine mightly about in_atomic
4637                 if ($line =~ /\bin_atomic\s*\(/) {
4638                         if ($realfile =~ m@^drivers/@) {
4639                                 ERROR("IN_ATOMIC",
4640                                       "do not use in_atomic in drivers\n" . $herecurr);
4641                         } elsif ($realfile !~ m@^kernel/@) {
4642                                 WARN("IN_ATOMIC",
4643                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4644                         }
4645                 }
4646
4647 # check for lockdep_set_novalidate_class
4648                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4649                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
4650                         if ($realfile !~ m@^kernel/lockdep@ &&
4651                             $realfile !~ m@^include/linux/lockdep@ &&
4652                             $realfile !~ m@^drivers/base/core@) {
4653                                 ERROR("LOCKDEP",
4654                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4655                         }
4656                 }
4657
4658                 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4659                     $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4660                         WARN("EXPORTED_WORLD_WRITABLE",
4661                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4662                 }
4663
4664 # Mode permission misuses where it seems decimal should be octal
4665 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
4666                 if ($^V && $^V ge 5.10.0 &&
4667                     $line =~ /$mode_perms_search/) {
4668                         foreach my $entry (@mode_permission_funcs) {
4669                                 my $func = $entry->[0];
4670                                 my $arg_pos = $entry->[1];
4671
4672                                 my $skip_args = "";
4673                                 if ($arg_pos > 1) {
4674                                         $arg_pos--;
4675                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4676                                 }
4677                                 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4678                                 if ($line =~ /$test/) {
4679                                         my $val = $1;
4680                                         $val = $6 if ($skip_args ne "");
4681
4682                                         if ($val !~ /^0$/ &&
4683                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4684                                              length($val) ne 4)) {
4685                                                 ERROR("NON_OCTAL_PERMISSIONS",
4686                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4687                                         }
4688                                 }
4689                         }
4690                 }
4691         }
4692
4693         # If we have no input at all, then there is nothing to report on
4694         # so just keep quiet.
4695         if ($#rawlines == -1) {
4696                 exit(0);
4697         }
4698
4699         # In mailback mode only produce a report in the negative, for
4700         # things that appear to be patches.
4701         if ($mailback && ($clean == 1 || !$is_patch)) {
4702                 exit(0);
4703         }
4704
4705         # This is not a patch, and we are are in 'no-patch' mode so
4706         # just keep quiet.
4707         if (!$chk_patch && !$is_patch) {
4708                 exit(0);
4709         }
4710
4711         if (!$is_patch) {
4712                 ERROR("NOT_UNIFIED_DIFF",
4713                       "Does not appear to be a unified-diff format patch\n");
4714         }
4715         if ($is_patch && $chk_signoff && $signoff == 0) {
4716                 ERROR("MISSING_SIGN_OFF",
4717                       "Missing Signed-off-by: line(s)\n");
4718         }
4719
4720         print report_dump();
4721         if ($summary && !($clean == 1 && $quiet == 1)) {
4722                 print "$filename " if ($summary_file);
4723                 print "total: $cnt_error errors, $cnt_warn warnings, " .
4724                         (($check)? "$cnt_chk checks, " : "") .
4725                         "$cnt_lines lines checked\n";
4726                 print "\n" if ($quiet == 0);
4727         }
4728
4729         if ($quiet == 0) {
4730
4731                 if ($^V lt 5.10.0) {
4732                         print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4733                         print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4734                 }
4735
4736                 # If there were whitespace errors which cleanpatch can fix
4737                 # then suggest that.
4738                 if ($rpt_cleaners) {
4739                         print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4740                         print "      scripts/cleanfile\n\n";
4741                         $rpt_cleaners = 0;
4742                 }
4743         }
4744
4745         hash_show_words(\%use_type, "Used");
4746         hash_show_words(\%ignore_type, "Ignored");
4747
4748         if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4749                 my $newfile = $filename;
4750                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4751                 my $linecount = 0;
4752                 my $f;
4753
4754                 open($f, '>', $newfile)
4755                     or die "$P: Can't open $newfile for write\n";
4756                 foreach my $fixed_line (@fixed) {
4757                         $linecount++;
4758                         if ($file) {
4759                                 if ($linecount > 3) {
4760                                         $fixed_line =~ s/^\+//;
4761                                         print $f $fixed_line. "\n";
4762                                 }
4763                         } else {
4764                                 print $f $fixed_line . "\n";
4765                         }
4766                 }
4767                 close($f);
4768
4769                 if (!$quiet) {
4770                         print << "EOM";
4771 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4772
4773 Do _NOT_ trust the results written to this file.
4774 Do _NOT_ submit these changes without inspecting them for correctness.
4775
4776 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4777 No warranties, expressed or implied...
4778
4779 EOM
4780                 }
4781         }
4782
4783         if ($clean == 1 && $quiet == 0) {
4784                 print "$vname has no obvious style problems and is ready for submission.\n"
4785         }
4786         if ($clean == 0 && $quiet == 0) {
4787                 print << "EOM";
4788 $vname has style problems, please review.
4789
4790 If any of these errors are false positives, please report
4791 them to the maintainer, see CHECKPATCH in MAINTAINERS.
4792 EOM
4793         }
4794
4795         return $clean;
4796 }