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 unwanted Gerrit info
1948                 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
1949                         ERROR("GERRIT_CHANGE_ID",
1950                               "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
1951                 }
1952
1953 # Check for wrappage within a valid hunk of the file
1954                 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1955                         ERROR("CORRUPTED_PATCH",
1956                               "patch seems to be corrupt (line wrapped?)\n" .
1957                                 $herecurr) if (!$emitted_corrupt++);
1958                 }
1959
1960 # Check for absolute kernel paths.
1961                 if ($tree) {
1962                         while ($line =~ m{(?:^|\s)(/\S*)}g) {
1963                                 my $file = $1;
1964
1965                                 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1966                                     check_absolute_file($1, $herecurr)) {
1967                                         #
1968                                 } else {
1969                                         check_absolute_file($file, $herecurr);
1970                                 }
1971                         }
1972                 }
1973
1974 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1975                 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1976                     $rawline !~ m/^$UTF8*$/) {
1977                         my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1978
1979                         my $blank = copy_spacing($rawline);
1980                         my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1981                         my $hereptr = "$hereline$ptr\n";
1982
1983                         CHK("INVALID_UTF8",
1984                             "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1985                 }
1986
1987 # Check if it's the start of a commit log
1988 # (not a header line and we haven't seen the patch filename)
1989                 if ($in_header_lines && $realfile =~ /^$/ &&
1990                     $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
1991                         $in_header_lines = 0;
1992                         $in_commit_log = 1;
1993                 }
1994
1995 # Check if there is UTF-8 in a commit log when a mail header has explicitly
1996 # declined it, i.e defined some charset where it is missing.
1997                 if ($in_header_lines &&
1998                     $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
1999                     $1 !~ /utf-8/i) {
2000                         $non_utf8_charset = 1;
2001                 }
2002
2003                 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2004                     $rawline =~ /$NON_ASCII_UTF8/) {
2005                         WARN("UTF8_BEFORE_PATCH",
2006                             "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2007                 }
2008
2009 # ignore non-hunk lines and lines being removed
2010                 next if (!$hunk_line || $line =~ /^-/);
2011
2012 #trailing whitespace
2013                 if ($line =~ /^\+.*\015/) {
2014                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2015                         if (ERROR("DOS_LINE_ENDINGS",
2016                                   "DOS line endings\n" . $herevet) &&
2017                             $fix) {
2018                                 $fixed[$linenr - 1] =~ s/[\s\015]+$//;
2019                         }
2020                 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2021                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2022                         if (ERROR("TRAILING_WHITESPACE",
2023                                   "trailing whitespace\n" . $herevet) &&
2024                             $fix) {
2025                                 $fixed[$linenr - 1] =~ s/\s+$//;
2026                         }
2027
2028                         $rpt_cleaners = 1;
2029                 }
2030
2031 # Check for FSF mailing addresses.
2032                 if ($rawline =~ /\bwrite to the Free/i ||
2033                     $rawline =~ /\b59\s+Temple\s+Pl/i ||
2034                     $rawline =~ /\b51\s+Franklin\s+St/i) {
2035                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2036                         my $msg_type = \&ERROR;
2037                         $msg_type = \&CHK if ($file);
2038                         &{$msg_type}("FSF_MAILING_ADDRESS",
2039                                      "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)
2040                 }
2041
2042 # check for Kconfig help text having a real description
2043 # Only applies when adding the entry originally, after that we do not have
2044 # sufficient context to determine whether it is indeed long enough.
2045                 if ($realfile =~ /Kconfig/ &&
2046                     $line =~ /.\s*config\s+/) {
2047                         my $length = 0;
2048                         my $cnt = $realcnt;
2049                         my $ln = $linenr + 1;
2050                         my $f;
2051                         my $is_start = 0;
2052                         my $is_end = 0;
2053                         for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2054                                 $f = $lines[$ln - 1];
2055                                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2056                                 $is_end = $lines[$ln - 1] =~ /^\+/;
2057
2058                                 next if ($f =~ /^-/);
2059
2060                                 if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
2061                                         $is_start = 1;
2062                                 } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
2063                                         $length = -1;
2064                                 }
2065
2066                                 $f =~ s/^.//;
2067                                 $f =~ s/#.*//;
2068                                 $f =~ s/^\s+//;
2069                                 next if ($f =~ /^$/);
2070                                 if ($f =~ /^\s*config\s/) {
2071                                         $is_end = 1;
2072                                         last;
2073                                 }
2074                                 $length++;
2075                         }
2076                         WARN("CONFIG_DESCRIPTION",
2077                              "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2078                         #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2079                 }
2080
2081 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2082                 if ($realfile =~ /Kconfig/ &&
2083                     $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2084                         WARN("CONFIG_EXPERIMENTAL",
2085                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2086                 }
2087
2088                 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2089                     ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2090                         my $flag = $1;
2091                         my $replacement = {
2092                                 'EXTRA_AFLAGS' =>   'asflags-y',
2093                                 'EXTRA_CFLAGS' =>   'ccflags-y',
2094                                 'EXTRA_CPPFLAGS' => 'cppflags-y',
2095                                 'EXTRA_LDFLAGS' =>  'ldflags-y',
2096                         };
2097
2098                         WARN("DEPRECATED_VARIABLE",
2099                              "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2100                 }
2101
2102 # check for DT compatible documentation
2103                 if (defined $root &&
2104                         (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2105                          ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2106
2107                         my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2108
2109                         my $dt_path = $root . "/Documentation/devicetree/bindings/";
2110                         my $vp_file = $dt_path . "vendor-prefixes.txt";
2111
2112                         foreach my $compat (@compats) {
2113                                 my $compat2 = $compat;
2114                                 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2115                                 my $compat3 = $compat;
2116                                 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2117                                 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2118                                 if ( $? >> 8 ) {
2119                                         WARN("UNDOCUMENTED_DT_STRING",
2120                                              "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2121                                 }
2122
2123                                 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2124                                 my $vendor = $1;
2125                                 `grep -Eq "^$vendor\\b" $vp_file`;
2126                                 if ( $? >> 8 ) {
2127                                         WARN("UNDOCUMENTED_DT_STRING",
2128                                              "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2129                                 }
2130                         }
2131                 }
2132
2133 # check we are in a valid source file if not then ignore this hunk
2134                 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2135
2136 #line length limit
2137                 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2138                     $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2139                     !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2140                     $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2141                     $length > $max_line_length)
2142                 {
2143                         WARN("LONG_LINE",
2144                              "line over $max_line_length characters\n" . $herecurr);
2145                 }
2146
2147 # Check for user-visible strings broken across lines, which breaks the ability
2148 # to grep for the string.  Make exceptions when the previous string ends in a
2149 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2150 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2151                 if ($line =~ /^\+\s*"/ &&
2152                     $prevline =~ /"\s*$/ &&
2153                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2154                         WARN("SPLIT_STRING",
2155                              "quoted string split across lines\n" . $hereprev);
2156                 }
2157
2158 # check for spaces before a quoted newline
2159                 if ($rawline =~ /^.*\".*\s\\n/) {
2160                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2161                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2162                             $fix) {
2163                                 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2164                         }
2165
2166                 }
2167
2168 # check for adding lines without a newline.
2169                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2170                         WARN("MISSING_EOF_NEWLINE",
2171                              "adding a line without newline at end of file\n" . $herecurr);
2172                 }
2173
2174 # Blackfin: use hi/lo macros
2175                 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2176                         if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2177                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2178                                 ERROR("LO_MACRO",
2179                                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2180                         }
2181                         if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2182                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2183                                 ERROR("HI_MACRO",
2184                                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2185                         }
2186                 }
2187
2188 # check we are in a valid source file C or perl if not then ignore this hunk
2189                 next if ($realfile !~ /\.(h|c|pl)$/);
2190
2191 # at the beginning of a line any tabs must come first and anything
2192 # more than 8 must use tabs.
2193                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2194                     $rawline =~ /^\+\s*        \s*/) {
2195                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2196                         $rpt_cleaners = 1;
2197                         if (ERROR("CODE_INDENT",
2198                                   "code indent should use tabs where possible\n" . $herevet) &&
2199                             $fix) {
2200                                 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2201                         }
2202                 }
2203
2204 # check for space before tabs.
2205                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2206                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2207                         if (WARN("SPACE_BEFORE_TAB",
2208                                 "please, no space before tabs\n" . $herevet) &&
2209                             $fix) {
2210                                 while ($fixed[$linenr - 1] =~
2211                                            s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2212                                 while ($fixed[$linenr - 1] =~
2213                                            s/(^\+.*) +\t/$1\t/) {}
2214                         }
2215                 }
2216
2217 # check for && or || at the start of a line
2218                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2219                         CHK("LOGICAL_CONTINUATIONS",
2220                             "Logical continuations should be on the previous line\n" . $hereprev);
2221                 }
2222
2223 # check multi-line statement indentation matches previous line
2224                 if ($^V && $^V ge 5.10.0 &&
2225                     $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2226                         $prevline =~ /^\+(\t*)(.*)$/;
2227                         my $oldindent = $1;
2228                         my $rest = $2;
2229
2230                         my $pos = pos_last_openparen($rest);
2231                         if ($pos >= 0) {
2232                                 $line =~ /^(\+| )([ \t]*)/;
2233                                 my $newindent = $2;
2234
2235                                 my $goodtabindent = $oldindent .
2236                                         "\t" x ($pos / 8) .
2237                                         " "  x ($pos % 8);
2238                                 my $goodspaceindent = $oldindent . " "  x $pos;
2239
2240                                 if ($newindent ne $goodtabindent &&
2241                                     $newindent ne $goodspaceindent) {
2242
2243                                         if (CHK("PARENTHESIS_ALIGNMENT",
2244                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
2245                                             $fix && $line =~ /^\+/) {
2246                                                 $fixed[$linenr - 1] =~
2247                                                     s/^\+[ \t]*/\+$goodtabindent/;
2248                                         }
2249                                 }
2250                         }
2251                 }
2252
2253                 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
2254                         if (CHK("SPACING",
2255                                 "No space is necessary after a cast\n" . $hereprev) &&
2256                             $fix) {
2257                                 $fixed[$linenr - 1] =~
2258                                     s/^(\+.*\*[ \t]*\))[ \t]+/$1/;
2259                         }
2260                 }
2261
2262                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2263                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2264                     $rawline =~ /^\+[ \t]*\*/ &&
2265                     $realline > 2) {
2266                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2267                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2268                 }
2269
2270                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2271                     $prevrawline =~ /^\+[ \t]*\/\*/ &&          #starting /*
2272                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
2273                     $rawline =~ /^\+/ &&                        #line is new
2274                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
2275                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2276                              "networking block comments start with * on subsequent lines\n" . $hereprev);
2277                 }
2278
2279                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2280                     $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
2281                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
2282                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
2283                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
2284                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2285                              "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2286                 }
2287
2288 # check for missing blank lines after declarations
2289                 if ($sline =~ /^\+\s+\S/ &&                     #Not at char 1
2290                         # actual declarations
2291                     ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2292                         # foo bar; where foo is some local typedef or #define
2293                      $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2294                         # known declaration macros
2295                      $prevline =~ /^\+\s+$declaration_macros/) &&
2296                         # for "else if" which can look like "$Ident $Ident"
2297                     !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2298                         # other possible extensions of declaration lines
2299                       $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2300                         # not starting a section or a macro "\" extended line
2301                       $prevline =~ /(?:\{\s*|\\)$/) &&
2302                         # looks like a declaration
2303                     !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2304                         # foo bar; where foo is some local typedef or #define
2305                       $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2306                         # known declaration macros
2307                       $sline =~ /^\+\s+$declaration_macros/ ||
2308                         # start of struct or union or enum
2309                       $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2310                         # start or end of block or continuation of declaration
2311                       $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2312                         # bitfield continuation
2313                       $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2314                         # other possible extensions of declaration lines
2315                       $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2316                         # indentation of previous and current line are the same
2317                     (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2318                         WARN("SPACING",
2319                              "Missing a blank line after declarations\n" . $hereprev);
2320                 }
2321
2322 # check for spaces at the beginning of a line.
2323 # Exceptions:
2324 #  1) within comments
2325 #  2) indented preprocessor commands
2326 #  3) hanging labels
2327                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2328                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2329                         if (WARN("LEADING_SPACE",
2330                                  "please, no spaces at the start of a line\n" . $herevet) &&
2331                             $fix) {
2332                                 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2333                         }
2334                 }
2335
2336 # check we are in a valid C source file if not then ignore this hunk
2337                 next if ($realfile !~ /\.(h|c)$/);
2338
2339 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2340                 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2341                         WARN("CONFIG_EXPERIMENTAL",
2342                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2343                 }
2344
2345 # check for RCS/CVS revision markers
2346                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2347                         WARN("CVS_KEYWORD",
2348                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2349                 }
2350
2351 # Blackfin: don't use __builtin_bfin_[cs]sync
2352                 if ($line =~ /__builtin_bfin_csync/) {
2353                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2354                         ERROR("CSYNC",
2355                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2356                 }
2357                 if ($line =~ /__builtin_bfin_ssync/) {
2358                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2359                         ERROR("SSYNC",
2360                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2361                 }
2362
2363 # check for old HOTPLUG __dev<foo> section markings
2364                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2365                         WARN("HOTPLUG_SECTION",
2366                              "Using $1 is unnecessary\n" . $herecurr);
2367                 }
2368
2369 # Check for potential 'bare' types
2370                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2371                     $realline_next);
2372 #print "LINE<$line>\n";
2373                 if ($linenr >= $suppress_statement &&
2374                     $realcnt && $sline =~ /.\s*\S/) {
2375                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2376                                 ctx_statement_block($linenr, $realcnt, 0);
2377                         $stat =~ s/\n./\n /g;
2378                         $cond =~ s/\n./\n /g;
2379
2380 #print "linenr<$linenr> <$stat>\n";
2381                         # If this statement has no statement boundaries within
2382                         # it there is no point in retrying a statement scan
2383                         # until we hit end of it.
2384                         my $frag = $stat; $frag =~ s/;+\s*$//;
2385                         if ($frag !~ /(?:{|;)/) {
2386 #print "skip<$line_nr_next>\n";
2387                                 $suppress_statement = $line_nr_next;
2388                         }
2389
2390                         # Find the real next line.
2391                         $realline_next = $line_nr_next;
2392                         if (defined $realline_next &&
2393                             (!defined $lines[$realline_next - 1] ||
2394                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2395                                 $realline_next++;
2396                         }
2397
2398                         my $s = $stat;
2399                         $s =~ s/{.*$//s;
2400
2401                         # Ignore goto labels.
2402                         if ($s =~ /$Ident:\*$/s) {
2403
2404                         # Ignore functions being called
2405                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2406
2407                         } elsif ($s =~ /^.\s*else\b/s) {
2408
2409                         # declarations always start with types
2410                         } 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) {
2411                                 my $type = $1;
2412                                 $type =~ s/\s+/ /g;
2413                                 possible($type, "A:" . $s);
2414
2415                         # definitions in global scope can only start with types
2416                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2417                                 possible($1, "B:" . $s);
2418                         }
2419
2420                         # any (foo ... *) is a pointer cast, and foo is a type
2421                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2422                                 possible($1, "C:" . $s);
2423                         }
2424
2425                         # Check for any sort of function declaration.
2426                         # int foo(something bar, other baz);
2427                         # void (*store_gdt)(x86_descr_ptr *);
2428                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2429                                 my ($name_len) = length($1);
2430
2431                                 my $ctx = $s;
2432                                 substr($ctx, 0, $name_len + 1, '');
2433                                 $ctx =~ s/\)[^\)]*$//;
2434
2435                                 for my $arg (split(/\s*,\s*/, $ctx)) {
2436                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2437
2438                                                 possible($1, "D:" . $s);
2439                                         }
2440                                 }
2441                         }
2442
2443                 }
2444
2445 #
2446 # Checks which may be anchored in the context.
2447 #
2448
2449 # Check for switch () and associated case and default
2450 # statements should be at the same indent.
2451                 if ($line=~/\bswitch\s*\(.*\)/) {
2452                         my $err = '';
2453                         my $sep = '';
2454                         my @ctx = ctx_block_outer($linenr, $realcnt);
2455                         shift(@ctx);
2456                         for my $ctx (@ctx) {
2457                                 my ($clen, $cindent) = line_stats($ctx);
2458                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2459                                                         $indent != $cindent) {
2460                                         $err .= "$sep$ctx\n";
2461                                         $sep = '';
2462                                 } else {
2463                                         $sep = "[...]\n";
2464                                 }
2465                         }
2466                         if ($err ne '') {
2467                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
2468                                       "switch and case should be at the same indent\n$hereline$err");
2469                         }
2470                 }
2471
2472 # if/while/etc brace do not go on next line, unless defining a do while loop,
2473 # or if that brace on the next line is for something else
2474                 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2475                         my $pre_ctx = "$1$2";
2476
2477                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2478
2479                         if ($line =~ /^\+\t{6,}/) {
2480                                 WARN("DEEP_INDENTATION",
2481                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
2482                         }
2483
2484                         my $ctx_cnt = $realcnt - $#ctx - 1;
2485                         my $ctx = join("\n", @ctx);
2486
2487                         my $ctx_ln = $linenr;
2488                         my $ctx_skip = $realcnt;
2489
2490                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2491                                         defined $lines[$ctx_ln - 1] &&
2492                                         $lines[$ctx_ln - 1] =~ /^-/)) {
2493                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2494                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2495                                 $ctx_ln++;
2496                         }
2497
2498                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2499                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2500
2501                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2502                                 ERROR("OPEN_BRACE",
2503                                       "that open brace { should be on the previous line\n" .
2504                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2505                         }
2506                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2507                             $ctx =~ /\)\s*\;\s*$/ &&
2508                             defined $lines[$ctx_ln - 1])
2509                         {
2510                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2511                                 if ($nindent > $indent) {
2512                                         WARN("TRAILING_SEMICOLON",
2513                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
2514                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2515                                 }
2516                         }
2517                 }
2518
2519 # Check relative indent for conditionals and blocks.
2520                 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2521                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2522                                 ctx_statement_block($linenr, $realcnt, 0)
2523                                         if (!defined $stat);
2524                         my ($s, $c) = ($stat, $cond);
2525
2526                         substr($s, 0, length($c), '');
2527
2528                         # Make sure we remove the line prefixes as we have
2529                         # none on the first line, and are going to readd them
2530                         # where necessary.
2531                         $s =~ s/\n./\n/gs;
2532
2533                         # Find out how long the conditional actually is.
2534                         my @newlines = ($c =~ /\n/gs);
2535                         my $cond_lines = 1 + $#newlines;
2536
2537                         # We want to check the first line inside the block
2538                         # starting at the end of the conditional, so remove:
2539                         #  1) any blank line termination
2540                         #  2) any opening brace { on end of the line
2541                         #  3) any do (...) {
2542                         my $continuation = 0;
2543                         my $check = 0;
2544                         $s =~ s/^.*\bdo\b//;
2545                         $s =~ s/^\s*{//;
2546                         if ($s =~ s/^\s*\\//) {
2547                                 $continuation = 1;
2548                         }
2549                         if ($s =~ s/^\s*?\n//) {
2550                                 $check = 1;
2551                                 $cond_lines++;
2552                         }
2553
2554                         # Also ignore a loop construct at the end of a
2555                         # preprocessor statement.
2556                         if (($prevline =~ /^.\s*#\s*define\s/ ||
2557                             $prevline =~ /\\\s*$/) && $continuation == 0) {
2558                                 $check = 0;
2559                         }
2560
2561                         my $cond_ptr = -1;
2562                         $continuation = 0;
2563                         while ($cond_ptr != $cond_lines) {
2564                                 $cond_ptr = $cond_lines;
2565
2566                                 # If we see an #else/#elif then the code
2567                                 # is not linear.
2568                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2569                                         $check = 0;
2570                                 }
2571
2572                                 # Ignore:
2573                                 #  1) blank lines, they should be at 0,
2574                                 #  2) preprocessor lines, and
2575                                 #  3) labels.
2576                                 if ($continuation ||
2577                                     $s =~ /^\s*?\n/ ||
2578                                     $s =~ /^\s*#\s*?/ ||
2579                                     $s =~ /^\s*$Ident\s*:/) {
2580                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2581                                         if ($s =~ s/^.*?\n//) {
2582                                                 $cond_lines++;
2583                                         }
2584                                 }
2585                         }
2586
2587                         my (undef, $sindent) = line_stats("+" . $s);
2588                         my $stat_real = raw_line($linenr, $cond_lines);
2589
2590                         # Check if either of these lines are modified, else
2591                         # this is not this patch's fault.
2592                         if (!defined($stat_real) ||
2593                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2594                                 $check = 0;
2595                         }
2596                         if (defined($stat_real) && $cond_lines > 1) {
2597                                 $stat_real = "[...]\n$stat_real";
2598                         }
2599
2600                         #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";
2601
2602                         if ($check && (($sindent % 8) != 0 ||
2603                             ($sindent <= $indent && $s ne ''))) {
2604                                 WARN("SUSPECT_CODE_INDENT",
2605                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2606                         }
2607                 }
2608
2609                 # Track the 'values' across context and added lines.
2610                 my $opline = $line; $opline =~ s/^./ /;
2611                 my ($curr_values, $curr_vars) =
2612                                 annotate_values($opline . "\n", $prev_values);
2613                 $curr_values = $prev_values . $curr_values;
2614                 if ($dbg_values) {
2615                         my $outline = $opline; $outline =~ s/\t/ /g;
2616                         print "$linenr > .$outline\n";
2617                         print "$linenr > $curr_values\n";
2618                         print "$linenr >  $curr_vars\n";
2619                 }
2620                 $prev_values = substr($curr_values, -1);
2621
2622 #ignore lines not being added
2623                 next if ($line =~ /^[^\+]/);
2624
2625 # TEST: allow direct testing of the type matcher.
2626                 if ($dbg_type) {
2627                         if ($line =~ /^.\s*$Declare\s*$/) {
2628                                 ERROR("TEST_TYPE",
2629                                       "TEST: is type\n" . $herecurr);
2630                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2631                                 ERROR("TEST_NOT_TYPE",
2632                                       "TEST: is not type ($1 is)\n". $herecurr);
2633                         }
2634                         next;
2635                 }
2636 # TEST: allow direct testing of the attribute matcher.
2637                 if ($dbg_attr) {
2638                         if ($line =~ /^.\s*$Modifier\s*$/) {
2639                                 ERROR("TEST_ATTR",
2640                                       "TEST: is attr\n" . $herecurr);
2641                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2642                                 ERROR("TEST_NOT_ATTR",
2643                                       "TEST: is not attr ($1 is)\n". $herecurr);
2644                         }
2645                         next;
2646                 }
2647
2648 # check for initialisation to aggregates open brace on the next line
2649                 if ($line =~ /^.\s*{/ &&
2650                     $prevline =~ /(?:^|[^=])=\s*$/) {
2651                         ERROR("OPEN_BRACE",
2652                               "that open brace { should be on the previous line\n" . $hereprev);
2653                 }
2654
2655 #
2656 # Checks which are anchored on the added line.
2657 #
2658
2659 # check for malformed paths in #include statements (uses RAW line)
2660                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2661                         my $path = $1;
2662                         if ($path =~ m{//}) {
2663                                 ERROR("MALFORMED_INCLUDE",
2664                                       "malformed #include filename\n" . $herecurr);
2665                         }
2666                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2667                                 ERROR("UAPI_INCLUDE",
2668                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2669                         }
2670                 }
2671
2672 # no C99 // comments
2673                 if ($line =~ m{//}) {
2674                         if (ERROR("C99_COMMENTS",
2675                                   "do not use C99 // comments\n" . $herecurr) &&
2676                             $fix) {
2677                                 my $line = $fixed[$linenr - 1];
2678                                 if ($line =~ /\/\/(.*)$/) {
2679                                         my $comment = trim($1);
2680                                         $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2681                                 }
2682                         }
2683                 }
2684                 # Remove C99 comments.
2685                 $line =~ s@//.*@@;
2686                 $opline =~ s@//.*@@;
2687
2688 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2689 # the whole statement.
2690 #print "APW <$lines[$realline_next - 1]>\n";
2691                 if (defined $realline_next &&
2692                     exists $lines[$realline_next - 1] &&
2693                     !defined $suppress_export{$realline_next} &&
2694                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2695                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2696                         # Handle definitions which produce identifiers with
2697                         # a prefix:
2698                         #   XXX(foo);
2699                         #   EXPORT_SYMBOL(something_foo);
2700                         my $name = $1;
2701                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
2702                             $name =~ /^${Ident}_$2/) {
2703 #print "FOO C name<$name>\n";
2704                                 $suppress_export{$realline_next} = 1;
2705
2706                         } elsif ($stat !~ /(?:
2707                                 \n.}\s*$|
2708                                 ^.DEFINE_$Ident\(\Q$name\E\)|
2709                                 ^.DECLARE_$Ident\(\Q$name\E\)|
2710                                 ^.LIST_HEAD\(\Q$name\E\)|
2711                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2712                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2713                             )/x) {
2714 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2715                                 $suppress_export{$realline_next} = 2;
2716                         } else {
2717                                 $suppress_export{$realline_next} = 1;
2718                         }
2719                 }
2720                 if (!defined $suppress_export{$linenr} &&
2721                     $prevline =~ /^.\s*$/ &&
2722                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2723                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2724 #print "FOO B <$lines[$linenr - 1]>\n";
2725                         $suppress_export{$linenr} = 2;
2726                 }
2727                 if (defined $suppress_export{$linenr} &&
2728                     $suppress_export{$linenr} == 2) {
2729                         WARN("EXPORT_SYMBOL",
2730                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2731                 }
2732
2733 # check for global initialisers.
2734                 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2735                         if (ERROR("GLOBAL_INITIALISERS",
2736                                   "do not initialise globals to 0 or NULL\n" .
2737                                       $herecurr) &&
2738                             $fix) {
2739                                 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2740                         }
2741                 }
2742 # check for static initialisers.
2743                 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2744                         if (ERROR("INITIALISED_STATIC",
2745                                   "do not initialise statics to 0 or NULL\n" .
2746                                       $herecurr) &&
2747                             $fix) {
2748                                 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2749                         }
2750                 }
2751
2752 # check for static const char * arrays.
2753                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2754                         WARN("STATIC_CONST_CHAR_ARRAY",
2755                              "static const char * array should probably be static const char * const\n" .
2756                                 $herecurr);
2757                }
2758
2759 # check for static char foo[] = "bar" declarations.
2760                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2761                         WARN("STATIC_CONST_CHAR_ARRAY",
2762                              "static char array declaration should probably be static const char\n" .
2763                                 $herecurr);
2764                }
2765
2766 # check for non-global char *foo[] = {"bar", ...} declarations.
2767                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
2768                         WARN("STATIC_CONST_CHAR_ARRAY",
2769                              "char * array declaration might be better as static const\n" .
2770                                 $herecurr);
2771                }
2772
2773 # check for function declarations without arguments like "int foo()"
2774                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2775                         if (ERROR("FUNCTION_WITHOUT_ARGS",
2776                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2777                             $fix) {
2778                                 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2779                         }
2780                 }
2781
2782 # check for uses of DEFINE_PCI_DEVICE_TABLE
2783                 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2784                         if (WARN("DEFINE_PCI_DEVICE_TABLE",
2785                                  "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2786                             $fix) {
2787                                 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2788                         }
2789                 }
2790
2791 # check for new typedefs, only function parameters and sparse annotations
2792 # make sense.
2793                 if ($line =~ /\btypedef\s/ &&
2794                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2795                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2796                     $line !~ /\b$typeTypedefs\b/ &&
2797                     $line !~ /\b__bitwise(?:__|)\b/) {
2798                         WARN("NEW_TYPEDEFS",
2799                              "do not add new typedefs\n" . $herecurr);
2800                 }
2801
2802 # * goes on variable not on type
2803                 # (char*[ const])
2804                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2805                         #print "AA<$1>\n";
2806                         my ($ident, $from, $to) = ($1, $2, $2);
2807
2808                         # Should start with a space.
2809                         $to =~ s/^(\S)/ $1/;
2810                         # Should not end with a space.
2811                         $to =~ s/\s+$//;
2812                         # '*'s should not have spaces between.
2813                         while ($to =~ s/\*\s+\*/\*\*/) {
2814                         }
2815
2816 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
2817                         if ($from ne $to) {
2818                                 if (ERROR("POINTER_LOCATION",
2819                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
2820                                     $fix) {
2821                                         my $sub_from = $ident;
2822                                         my $sub_to = $ident;
2823                                         $sub_to =~ s/\Q$from\E/$to/;
2824                                         $fixed[$linenr - 1] =~
2825                                             s@\Q$sub_from\E@$sub_to@;
2826                                 }
2827                         }
2828                 }
2829                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2830                         #print "BB<$1>\n";
2831                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
2832
2833                         # Should start with a space.
2834                         $to =~ s/^(\S)/ $1/;
2835                         # Should not end with a space.
2836                         $to =~ s/\s+$//;
2837                         # '*'s should not have spaces between.
2838                         while ($to =~ s/\*\s+\*/\*\*/) {
2839                         }
2840                         # Modifiers should have spaces.
2841                         $to =~ s/(\b$Modifier$)/$1 /;
2842
2843 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
2844                         if ($from ne $to && $ident !~ /^$Modifier$/) {
2845                                 if (ERROR("POINTER_LOCATION",
2846                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
2847                                     $fix) {
2848
2849                                         my $sub_from = $match;
2850                                         my $sub_to = $match;
2851                                         $sub_to =~ s/\Q$from\E/$to/;
2852                                         $fixed[$linenr - 1] =~
2853                                             s@\Q$sub_from\E@$sub_to@;
2854                                 }
2855                         }
2856                 }
2857
2858 # # no BUG() or BUG_ON()
2859 #               if ($line =~ /\b(BUG|BUG_ON)\b/) {
2860 #                       print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2861 #                       print "$herecurr";
2862 #                       $clean = 0;
2863 #               }
2864
2865                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2866                         WARN("LINUX_VERSION_CODE",
2867                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2868                 }
2869
2870 # check for uses of printk_ratelimit
2871                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2872                         WARN("PRINTK_RATELIMITED",
2873 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2874                 }
2875
2876 # printk should use KERN_* levels.  Note that follow on printk's on the
2877 # same line do not need a level, so we use the current block context
2878 # to try and find and validate the current printk.  In summary the current
2879 # printk includes all preceding printk's which have no newline on the end.
2880 # we assume the first bad printk is the one to report.
2881                 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2882                         my $ok = 0;
2883                         for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2884                                 #print "CHECK<$lines[$ln - 1]\n";
2885                                 # we have a preceding printk if it ends
2886                                 # with "\n" ignore it, else it is to blame
2887                                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2888                                         if ($rawlines[$ln - 1] !~ m{\\n"}) {
2889                                                 $ok = 1;
2890                                         }
2891                                         last;
2892                                 }
2893                         }
2894                         if ($ok == 0) {
2895                                 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2896                                      "printk() should include KERN_ facility level\n" . $herecurr);
2897                         }
2898                 }
2899
2900                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2901                         my $orig = $1;
2902                         my $level = lc($orig);
2903                         $level = "warn" if ($level eq "warning");
2904                         my $level2 = $level;
2905                         $level2 = "dbg" if ($level eq "debug");
2906                         WARN("PREFER_PR_LEVEL",
2907                              "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
2908                 }
2909
2910                 if ($line =~ /\bpr_warning\s*\(/) {
2911                         if (WARN("PREFER_PR_LEVEL",
2912                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2913                             $fix) {
2914                                 $fixed[$linenr - 1] =~
2915                                     s/\bpr_warning\b/pr_warn/;
2916                         }
2917                 }
2918
2919                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2920                         my $orig = $1;
2921                         my $level = lc($orig);
2922                         $level = "warn" if ($level eq "warning");
2923                         $level = "dbg" if ($level eq "debug");
2924                         WARN("PREFER_DEV_LEVEL",
2925                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2926                 }
2927
2928 # function brace can't be on same line, except for #defines of do while,
2929 # or if closed on same line
2930                 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2931                     !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2932                         ERROR("OPEN_BRACE",
2933                               "open brace '{' following function declarations go on the next line\n" . $herecurr);
2934                 }
2935
2936 # open braces for enum, union and struct go on the same line.
2937                 if ($line =~ /^.\s*{/ &&
2938                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2939                         ERROR("OPEN_BRACE",
2940                               "open brace '{' following $1 go on the same line\n" . $hereprev);
2941                 }
2942
2943 # missing space after union, struct or enum definition
2944                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2945                         if (WARN("SPACING",
2946                                  "missing space after $1 definition\n" . $herecurr) &&
2947                             $fix) {
2948                                 $fixed[$linenr - 1] =~
2949                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
2950                         }
2951                 }
2952
2953 # Function pointer declarations
2954 # check spacing between type, funcptr, and args
2955 # canonical declaration is "type (*funcptr)(args...)"
2956                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
2957                         my $declare = $1;
2958                         my $pre_pointer_space = $2;
2959                         my $post_pointer_space = $3;
2960                         my $funcname = $4;
2961                         my $post_funcname_space = $5;
2962                         my $pre_args_space = $6;
2963
2964 # the $Declare variable will capture all spaces after the type
2965 # so check it for a missing trailing missing space but pointer return types
2966 # don't need a space so don't warn for those.
2967                         my $post_declare_space = "";
2968                         if ($declare =~ /(\s+)$/) {
2969                                 $post_declare_space = $1;
2970                                 $declare = rtrim($declare);
2971                         }
2972                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
2973                                 WARN("SPACING",
2974                                      "missing space after return type\n" . $herecurr);
2975                                 $post_declare_space = " ";
2976                         }
2977
2978 # unnecessary space "type  (*funcptr)(args...)"
2979 # This test is not currently implemented because these declarations are
2980 # equivalent to
2981 #       int  foo(int bar, ...)
2982 # and this is form shouldn't/doesn't generate a checkpatch warning.
2983 #
2984 #                       elsif ($declare =~ /\s{2,}$/) {
2985 #                               WARN("SPACING",
2986 #                                    "Multiple spaces after return type\n" . $herecurr);
2987 #                       }
2988
2989 # unnecessary space "type ( *funcptr)(args...)"
2990                         if (defined $pre_pointer_space &&
2991                             $pre_pointer_space =~ /^\s/) {
2992                                 WARN("SPACING",
2993                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
2994                         }
2995
2996 # unnecessary space "type (* funcptr)(args...)"
2997                         if (defined $post_pointer_space &&
2998                             $post_pointer_space =~ /^\s/) {
2999                                 WARN("SPACING",
3000                                      "Unnecessary space before function pointer name\n" . $herecurr);
3001                         }
3002
3003 # unnecessary space "type (*funcptr )(args...)"
3004                         if (defined $post_funcname_space &&
3005                             $post_funcname_space =~ /^\s/) {
3006                                 WARN("SPACING",
3007                                      "Unnecessary space after function pointer name\n" . $herecurr);
3008                         }
3009
3010 # unnecessary space "type (*funcptr) (args...)"
3011                         if (defined $pre_args_space &&
3012                             $pre_args_space =~ /^\s/) {
3013                                 WARN("SPACING",
3014                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
3015                         }
3016
3017                         if (show_type("SPACING") && $fix) {
3018                                 $fixed[$linenr - 1] =~
3019                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3020                         }
3021                 }
3022
3023 # check for spacing round square brackets; allowed:
3024 #  1. with a type on the left -- int [] a;
3025 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3026 #  3. inside a curly brace -- = { [0...10] = 5 }
3027                 while ($line =~ /(.*?\s)\[/g) {
3028                         my ($where, $prefix) = ($-[1], $1);
3029                         if ($prefix !~ /$Type\s+$/ &&
3030                             ($where != 0 || $prefix !~ /^.\s+$/) &&
3031                             $prefix !~ /[{,]\s+$/) {
3032                                 if (ERROR("BRACKET_SPACE",
3033                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
3034                                     $fix) {
3035                                     $fixed[$linenr - 1] =~
3036                                         s/^(\+.*?)\s+\[/$1\[/;
3037                                 }
3038                         }
3039                 }
3040
3041 # check for spaces between functions and their parentheses.
3042                 while ($line =~ /($Ident)\s+\(/g) {
3043                         my $name = $1;
3044                         my $ctx_before = substr($line, 0, $-[1]);
3045                         my $ctx = "$ctx_before$name";
3046
3047                         # Ignore those directives where spaces _are_ permitted.
3048                         if ($name =~ /^(?:
3049                                 if|for|while|switch|return|case|
3050                                 volatile|__volatile__|
3051                                 __attribute__|format|__extension__|
3052                                 asm|__asm__)$/x)
3053                         {
3054                         # cpp #define statements have non-optional spaces, ie
3055                         # if there is a space between the name and the open
3056                         # parenthesis it is simply not a parameter group.
3057                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3058
3059                         # cpp #elif statement condition may start with a (
3060                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3061
3062                         # If this whole things ends with a type its most
3063                         # likely a typedef for a function.
3064                         } elsif ($ctx =~ /$Type$/) {
3065
3066                         } else {
3067                                 if (WARN("SPACING",
3068                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3069                                              $fix) {
3070                                         $fixed[$linenr - 1] =~
3071                                             s/\b$name\s+\(/$name\(/;
3072                                 }
3073                         }
3074                 }
3075
3076 # Check operator spacing.
3077                 if (!($line=~/\#\s*include/)) {
3078                         my $fixed_line = "";
3079                         my $line_fixed = 0;
3080
3081                         my $ops = qr{
3082                                 <<=|>>=|<=|>=|==|!=|
3083                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3084                                 =>|->|<<|>>|<|>|=|!|~|
3085                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3086                                 \?:|\?|:
3087                         }x;
3088                         my @elements = split(/($ops|;)/, $opline);
3089
3090 ##                      print("element count: <" . $#elements . ">\n");
3091 ##                      foreach my $el (@elements) {
3092 ##                              print("el: <$el>\n");
3093 ##                      }
3094
3095                         my @fix_elements = ();
3096                         my $off = 0;
3097
3098                         foreach my $el (@elements) {
3099                                 push(@fix_elements, substr($rawline, $off, length($el)));
3100                                 $off += length($el);
3101                         }
3102
3103                         $off = 0;
3104
3105                         my $blank = copy_spacing($opline);
3106                         my $last_after = -1;
3107
3108                         for (my $n = 0; $n < $#elements; $n += 2) {
3109
3110                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3111
3112 ##                              print("n: <$n> good: <$good>\n");
3113
3114                                 $off += length($elements[$n]);
3115
3116                                 # Pick up the preceding and succeeding characters.
3117                                 my $ca = substr($opline, 0, $off);
3118                                 my $cc = '';
3119                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3120                                         $cc = substr($opline, $off + length($elements[$n + 1]));
3121                                 }
3122                                 my $cb = "$ca$;$cc";
3123
3124                                 my $a = '';
3125                                 $a = 'V' if ($elements[$n] ne '');
3126                                 $a = 'W' if ($elements[$n] =~ /\s$/);
3127                                 $a = 'C' if ($elements[$n] =~ /$;$/);
3128                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3129                                 $a = 'O' if ($elements[$n] eq '');
3130                                 $a = 'E' if ($ca =~ /^\s*$/);
3131
3132                                 my $op = $elements[$n + 1];
3133
3134                                 my $c = '';
3135                                 if (defined $elements[$n + 2]) {
3136                                         $c = 'V' if ($elements[$n + 2] ne '');
3137                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3138                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3139                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3140                                         $c = 'O' if ($elements[$n + 2] eq '');
3141                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3142                                 } else {
3143                                         $c = 'E';
3144                                 }
3145
3146                                 my $ctx = "${a}x${c}";
3147
3148                                 my $at = "(ctx:$ctx)";
3149
3150                                 my $ptr = substr($blank, 0, $off) . "^";
3151                                 my $hereptr = "$hereline$ptr\n";
3152
3153                                 # Pull out the value of this operator.
3154                                 my $op_type = substr($curr_values, $off + 1, 1);
3155
3156                                 # Get the full operator variant.
3157                                 my $opv = $op . substr($curr_vars, $off, 1);
3158
3159                                 # Ignore operators passed as parameters.
3160                                 if ($op_type ne 'V' &&
3161                                     $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3162
3163 #                               # Ignore comments
3164 #                               } elsif ($op =~ /^$;+$/) {
3165
3166                                 # ; should have either the end of line or a space or \ after it
3167                                 } elsif ($op eq ';') {
3168                                         if ($ctx !~ /.x[WEBC]/ &&
3169                                             $cc !~ /^\\/ && $cc !~ /^;/) {
3170                                                 if (ERROR("SPACING",
3171                                                           "space required after that '$op' $at\n" . $hereptr)) {
3172                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3173                                                         $line_fixed = 1;
3174                                                 }
3175                                         }
3176
3177                                 # // is a comment
3178                                 } elsif ($op eq '//') {
3179
3180                                 #   :   when part of a bitfield
3181                                 } elsif ($opv eq ':B') {
3182                                         # skip the bitfield test for now
3183
3184                                 # No spaces for:
3185                                 #   ->
3186                                 } elsif ($op eq '->') {
3187                                         if ($ctx =~ /Wx.|.xW/) {
3188                                                 if (ERROR("SPACING",
3189                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3190                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3191                                                         if (defined $fix_elements[$n + 2]) {
3192                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3193                                                         }
3194                                                         $line_fixed = 1;
3195                                                 }
3196                                         }
3197
3198                                 # , must have a space on the right.
3199                                 } elsif ($op eq ',') {
3200                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3201                                                 if (ERROR("SPACING",
3202                                                           "space required after that '$op' $at\n" . $hereptr)) {
3203                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3204                                                         $line_fixed = 1;
3205                                                         $last_after = $n;
3206                                                 }
3207                                         }
3208
3209                                 # '*' as part of a type definition -- reported already.
3210                                 } elsif ($opv eq '*_') {
3211                                         #warn "'*' is part of type\n";
3212
3213                                 # unary operators should have a space before and
3214                                 # none after.  May be left adjacent to another
3215                                 # unary operator, or a cast
3216                                 } elsif ($op eq '!' || $op eq '~' ||
3217                                          $opv eq '*U' || $opv eq '-U' ||
3218                                          $opv eq '&U' || $opv eq '&&U') {
3219                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3220                                                 if (ERROR("SPACING",
3221                                                           "space required before that '$op' $at\n" . $hereptr)) {
3222                                                         if ($n != $last_after + 2) {
3223                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3224                                                                 $line_fixed = 1;
3225                                                         }
3226                                                 }
3227                                         }
3228                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3229                                                 # A unary '*' may be const
3230
3231                                         } elsif ($ctx =~ /.xW/) {
3232                                                 if (ERROR("SPACING",
3233                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3234                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3235                                                         if (defined $fix_elements[$n + 2]) {
3236                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3237                                                         }
3238                                                         $line_fixed = 1;
3239                                                 }
3240                                         }
3241
3242                                 # unary ++ and unary -- are allowed no space on one side.
3243                                 } elsif ($op eq '++' or $op eq '--') {
3244                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3245                                                 if (ERROR("SPACING",
3246                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
3247                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3248                                                         $line_fixed = 1;
3249                                                 }
3250                                         }
3251                                         if ($ctx =~ /Wx[BE]/ ||
3252                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3253                                                 if (ERROR("SPACING",
3254                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3255                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3256                                                         $line_fixed = 1;
3257                                                 }
3258                                         }
3259                                         if ($ctx =~ /ExW/) {
3260                                                 if (ERROR("SPACING",
3261                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3262                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3263                                                         if (defined $fix_elements[$n + 2]) {
3264                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3265                                                         }
3266                                                         $line_fixed = 1;
3267                                                 }
3268                                         }
3269
3270                                 # << and >> may either have or not have spaces both sides
3271                                 } elsif ($op eq '<<' or $op eq '>>' or
3272                                          $op eq '&' or $op eq '^' or $op eq '|' or
3273                                          $op eq '+' or $op eq '-' or
3274                                          $op eq '*' or $op eq '/' or
3275                                          $op eq '%')
3276                                 {
3277                                         if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3278                                                 if (ERROR("SPACING",
3279                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
3280                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3281                                                         if (defined $fix_elements[$n + 2]) {
3282                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3283                                                         }
3284                                                         $line_fixed = 1;
3285                                                 }
3286                                         }
3287
3288                                 # A colon needs no spaces before when it is
3289                                 # terminating a case value or a label.
3290                                 } elsif ($opv eq ':C' || $opv eq ':L') {
3291                                         if ($ctx =~ /Wx./) {
3292                                                 if (ERROR("SPACING",
3293                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3294                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3295                                                         $line_fixed = 1;
3296                                                 }
3297                                         }
3298
3299                                 # All the others need spaces both sides.
3300                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3301                                         my $ok = 0;
3302
3303                                         # Ignore email addresses <foo@bar>
3304                                         if (($op eq '<' &&
3305                                              $cc =~ /^\S+\@\S+>/) ||
3306                                             ($op eq '>' &&
3307                                              $ca =~ /<\S+\@\S+$/))
3308                                         {
3309                                                 $ok = 1;
3310                                         }
3311
3312                                         # messages are ERROR, but ?: are CHK
3313                                         if ($ok == 0) {
3314                                                 my $msg_type = \&ERROR;
3315                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3316
3317                                                 if (&{$msg_type}("SPACING",
3318                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {
3319                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3320                                                         if (defined $fix_elements[$n + 2]) {
3321                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3322                                                         }
3323                                                         $line_fixed = 1;
3324                                                 }
3325                                         }
3326                                 }
3327                                 $off += length($elements[$n + 1]);
3328
3329 ##                              print("n: <$n> GOOD: <$good>\n");
3330
3331                                 $fixed_line = $fixed_line . $good;
3332                         }
3333
3334                         if (($#elements % 2) == 0) {
3335                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
3336                         }
3337
3338                         if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3339                                 $fixed[$linenr - 1] = $fixed_line;
3340                         }
3341
3342
3343                 }
3344
3345 # check for whitespace before a non-naked semicolon
3346                 if ($line =~ /^\+.*\S\s+;\s*$/) {
3347                         if (WARN("SPACING",
3348                                  "space prohibited before semicolon\n" . $herecurr) &&
3349                             $fix) {
3350                                 1 while $fixed[$linenr - 1] =~
3351                                     s/^(\+.*\S)\s+;/$1;/;
3352                         }
3353                 }
3354
3355 # check for multiple assignments
3356                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3357                         CHK("MULTIPLE_ASSIGNMENTS",
3358                             "multiple assignments should be avoided\n" . $herecurr);
3359                 }
3360
3361 ## # check for multiple declarations, allowing for a function declaration
3362 ## # continuation.
3363 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3364 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3365 ##
3366 ##                      # Remove any bracketed sections to ensure we do not
3367 ##                      # falsly report the parameters of functions.
3368 ##                      my $ln = $line;
3369 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
3370 ##                      }
3371 ##                      if ($ln =~ /,/) {
3372 ##                              WARN("MULTIPLE_DECLARATION",
3373 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
3374 ##                      }
3375 ##              }
3376
3377 #need space before brace following if, while, etc
3378                 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3379                     $line =~ /do{/) {
3380                         if (ERROR("SPACING",
3381                                   "space required before the open brace '{'\n" . $herecurr) &&
3382                             $fix) {
3383                                 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3384                         }
3385                 }
3386
3387 ## # check for blank lines before declarations
3388 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3389 ##                  $prevrawline =~ /^.\s*$/) {
3390 ##                      WARN("SPACING",
3391 ##                           "No blank lines before declarations\n" . $hereprev);
3392 ##              }
3393 ##
3394
3395 # closing brace should have a space following it when it has anything
3396 # on the line
3397                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3398                         if (ERROR("SPACING",
3399                                   "space required after that close brace '}'\n" . $herecurr) &&
3400                             $fix) {
3401                                 $fixed[$linenr - 1] =~
3402                                     s/}((?!(?:,|;|\)))\S)/} $1/;
3403                         }
3404                 }
3405
3406 # check spacing on square brackets
3407                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3408                         if (ERROR("SPACING",
3409                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
3410                             $fix) {
3411                                 $fixed[$linenr - 1] =~
3412                                     s/\[\s+/\[/;
3413                         }
3414                 }
3415                 if ($line =~ /\s\]/) {
3416                         if (ERROR("SPACING",
3417                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3418                             $fix) {
3419                                 $fixed[$linenr - 1] =~
3420                                     s/\s+\]/\]/;
3421                         }
3422                 }
3423
3424 # check spacing on parentheses
3425                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3426                     $line !~ /for\s*\(\s+;/) {
3427                         if (ERROR("SPACING",
3428                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3429                             $fix) {
3430                                 $fixed[$linenr - 1] =~
3431                                     s/\(\s+/\(/;
3432                         }
3433                 }
3434                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3435                     $line !~ /for\s*\(.*;\s+\)/ &&
3436                     $line !~ /:\s+\)/) {
3437                         if (ERROR("SPACING",
3438                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3439                             $fix) {
3440                                 $fixed[$linenr - 1] =~
3441                                     s/\s+\)/\)/;
3442                         }
3443                 }
3444
3445 #goto labels aren't indented, allow a single space however
3446                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3447                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3448                         if (WARN("INDENTED_LABEL",
3449                                  "labels should not be indented\n" . $herecurr) &&
3450                             $fix) {
3451                                 $fixed[$linenr - 1] =~
3452                                     s/^(.)\s+/$1/;
3453                         }
3454                 }
3455
3456 # return is not a function
3457                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3458                         my $spacing = $1;
3459                         if ($^V && $^V ge 5.10.0 &&
3460                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3461                                 my $value = $1;
3462                                 $value = deparenthesize($value);
3463                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3464                                         ERROR("RETURN_PARENTHESES",
3465                                               "return is not a function, parentheses are not required\n" . $herecurr);
3466                                 }
3467                         } elsif ($spacing !~ /\s+/) {
3468                                 ERROR("SPACING",
3469                                       "space required before the open parenthesis '('\n" . $herecurr);
3470                         }
3471                 }
3472
3473 # unnecessary return in a void function? (a single leading tab, then return;)
3474                 if ($sline =~ /^\+\treturn\s*;\s*$/ &&
3475                     $prevline =~ /^\+/) {
3476                         WARN("RETURN_VOID",
3477                              "void function return statements are not generally useful\n" . $herecurr);
3478                 }
3479
3480 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3481                 if ($^V && $^V ge 5.10.0 &&
3482                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
3483                         my $openparens = $1;
3484                         my $count = $openparens =~ tr@\(@\(@;
3485                         my $msg = "";
3486                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3487                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
3488                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
3489                                 WARN("UNNECESSARY_PARENTHESES",
3490                                      "Unnecessary parentheses$msg\n" . $herecurr);
3491                         }
3492                 }
3493
3494 # Return of what appears to be an errno should normally be -'ve
3495                 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3496                         my $name = $1;
3497                         if ($name ne 'EOF' && $name ne 'ERROR') {
3498                                 WARN("USE_NEGATIVE_ERRNO",
3499                                      "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3500                         }
3501                 }
3502
3503 # Need a space before open parenthesis after if, while etc
3504                 if ($line =~ /\b(if|while|for|switch)\(/) {
3505                         if (ERROR("SPACING",
3506                                   "space required before the open parenthesis '('\n" . $herecurr) &&
3507                             $fix) {
3508                                 $fixed[$linenr - 1] =~
3509                                     s/\b(if|while|for|switch)\(/$1 \(/;
3510                         }
3511                 }
3512
3513 # Check for illegal assignment in if conditional -- and check for trailing
3514 # statements after the conditional.
3515                 if ($line =~ /do\s*(?!{)/) {
3516                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3517                                 ctx_statement_block($linenr, $realcnt, 0)
3518                                         if (!defined $stat);
3519                         my ($stat_next) = ctx_statement_block($line_nr_next,
3520                                                 $remain_next, $off_next);
3521                         $stat_next =~ s/\n./\n /g;
3522                         ##print "stat<$stat> stat_next<$stat_next>\n";
3523
3524                         if ($stat_next =~ /^\s*while\b/) {
3525                                 # If the statement carries leading newlines,
3526                                 # then count those as offsets.
3527                                 my ($whitespace) =
3528                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3529                                 my $offset =
3530                                         statement_rawlines($whitespace) - 1;
3531
3532                                 $suppress_whiletrailers{$line_nr_next +
3533                                                                 $offset} = 1;
3534                         }
3535                 }
3536                 if (!defined $suppress_whiletrailers{$linenr} &&
3537                     defined($stat) && defined($cond) &&
3538                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3539                         my ($s, $c) = ($stat, $cond);
3540
3541                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3542                                 ERROR("ASSIGN_IN_IF",
3543                                       "do not use assignment in if condition\n" . $herecurr);
3544                         }
3545
3546                         # Find out what is on the end of the line after the
3547                         # conditional.
3548                         substr($s, 0, length($c), '');
3549                         $s =~ s/\n.*//g;
3550                         $s =~ s/$;//g;  # Remove any comments
3551                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3552                             $c !~ /}\s*while\s*/)
3553                         {
3554                                 # Find out how long the conditional actually is.
3555                                 my @newlines = ($c =~ /\n/gs);
3556                                 my $cond_lines = 1 + $#newlines;
3557                                 my $stat_real = '';
3558
3559                                 $stat_real = raw_line($linenr, $cond_lines)
3560                                                         . "\n" if ($cond_lines);
3561                                 if (defined($stat_real) && $cond_lines > 1) {
3562                                         $stat_real = "[...]\n$stat_real";
3563                                 }
3564
3565                                 ERROR("TRAILING_STATEMENTS",
3566                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
3567                         }
3568                 }
3569
3570 # Check for bitwise tests written as boolean
3571                 if ($line =~ /
3572                         (?:
3573                                 (?:\[|\(|\&\&|\|\|)
3574                                 \s*0[xX][0-9]+\s*
3575                                 (?:\&\&|\|\|)
3576                         |
3577                                 (?:\&\&|\|\|)
3578                                 \s*0[xX][0-9]+\s*
3579                                 (?:\&\&|\|\||\)|\])
3580                         )/x)
3581                 {
3582                         WARN("HEXADECIMAL_BOOLEAN_TEST",
3583                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3584                 }
3585
3586 # if and else should not have general statements after it
3587                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3588                         my $s = $1;
3589                         $s =~ s/$;//g;  # Remove any comments
3590                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3591                                 ERROR("TRAILING_STATEMENTS",
3592                                       "trailing statements should be on next line\n" . $herecurr);
3593                         }
3594                 }
3595 # if should not continue a brace
3596                 if ($line =~ /}\s*if\b/) {
3597                         ERROR("TRAILING_STATEMENTS",
3598                               "trailing statements should be on next line\n" .
3599                                 $herecurr);
3600                 }
3601 # case and default should not have general statements after them
3602                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3603                     $line !~ /\G(?:
3604                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3605                         \s*return\s+
3606                     )/xg)
3607                 {
3608                         ERROR("TRAILING_STATEMENTS",
3609                               "trailing statements should be on next line\n" . $herecurr);
3610                 }
3611
3612                 # Check for }<nl>else {, these must be at the same
3613                 # indent level to be relevant to each other.
3614                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3615                                                 $previndent == $indent) {
3616                         ERROR("ELSE_AFTER_BRACE",
3617                               "else should follow close brace '}'\n" . $hereprev);
3618                 }
3619
3620                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3621                                                 $previndent == $indent) {
3622                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3623
3624                         # Find out what is on the end of the line after the
3625                         # conditional.
3626                         substr($s, 0, length($c), '');
3627                         $s =~ s/\n.*//g;
3628
3629                         if ($s =~ /^\s*;/) {
3630                                 ERROR("WHILE_AFTER_BRACE",
3631                                       "while should follow close brace '}'\n" . $hereprev);
3632                         }
3633                 }
3634
3635 #Specific variable tests
3636                 while ($line =~ m{($Constant|$Lval)}g) {
3637                         my $var = $1;
3638
3639 #gcc binary extension
3640                         if ($var =~ /^$Binary$/) {
3641                                 if (WARN("GCC_BINARY_CONSTANT",
3642                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3643                                     $fix) {
3644                                         my $hexval = sprintf("0x%x", oct($var));
3645                                         $fixed[$linenr - 1] =~
3646                                             s/\b$var\b/$hexval/;
3647                                 }
3648                         }
3649
3650 #CamelCase
3651                         if ($var !~ /^$Constant$/ &&
3652                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3653 #Ignore Page<foo> variants
3654                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3655 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3656                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3657                                 while ($var =~ m{($Ident)}g) {
3658                                         my $word = $1;
3659                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3660                                         if ($check) {
3661                                                 seed_camelcase_includes();
3662                                                 if (!$file && !$camelcase_file_seeded) {
3663                                                         seed_camelcase_file($realfile);
3664                                                         $camelcase_file_seeded = 1;
3665                                                 }
3666                                         }
3667                                         if (!defined $camelcase{$word}) {
3668                                                 $camelcase{$word} = 1;
3669                                                 CHK("CAMELCASE",
3670                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
3671                                         }
3672                                 }
3673                         }
3674                 }
3675
3676 #no spaces allowed after \ in define
3677                 if ($line =~ /\#\s*define.*\\\s+$/) {
3678                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3679                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3680                             $fix) {
3681                                 $fixed[$linenr - 1] =~ s/\s+$//;
3682                         }
3683                 }
3684
3685 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3686                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3687                         my $file = "$1.h";
3688                         my $checkfile = "include/linux/$file";
3689                         if (-f "$root/$checkfile" &&
3690                             $realfile ne $checkfile &&
3691                             $1 !~ /$allowed_asm_includes/)
3692                         {
3693                                 if ($realfile =~ m{^arch/}) {
3694                                         CHK("ARCH_INCLUDE_LINUX",
3695                                             "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3696                                 } else {
3697                                         WARN("INCLUDE_LINUX",
3698                                              "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3699                                 }
3700                         }
3701                 }
3702
3703 # multi-statement macros should be enclosed in a do while loop, grab the
3704 # first statement and ensure its the whole macro if its not enclosed
3705 # in a known good container
3706                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3707                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3708                         my $ln = $linenr;
3709                         my $cnt = $realcnt;
3710                         my ($off, $dstat, $dcond, $rest);
3711                         my $ctx = '';
3712                         ($dstat, $dcond, $ln, $cnt, $off) =
3713                                 ctx_statement_block($linenr, $realcnt, 0);
3714                         $ctx = $dstat;
3715                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3716                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3717
3718                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3719                         $dstat =~ s/$;//g;
3720                         $dstat =~ s/\\\n.//g;
3721                         $dstat =~ s/^\s*//s;
3722                         $dstat =~ s/\s*$//s;
3723
3724                         # Flatten any parentheses and braces
3725                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3726                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
3727                                $dstat =~ s/\[[^\[\]]*\]/1/)
3728                         {
3729                         }
3730
3731                         # Flatten any obvious string concatentation.
3732                         while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3733                                $dstat =~ s/$Ident\s*("X*")/$1/)
3734                         {
3735                         }
3736
3737                         my $exceptions = qr{
3738                                 $Declare|
3739                                 module_param_named|
3740                                 MODULE_PARM_DESC|
3741                                 DECLARE_PER_CPU|
3742                                 DEFINE_PER_CPU|
3743                                 __typeof__\(|
3744                                 union|
3745                                 struct|
3746                                 \.$Ident\s*=\s*|
3747                                 ^\"|\"$
3748                         }x;
3749                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3750                         if ($dstat ne '' &&
3751                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
3752                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
3753                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3754                             $dstat !~ /^'X'$/ &&                                        # character constants
3755                             $dstat !~ /$exceptions/ &&
3756                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
3757                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
3758                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
3759                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
3760                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
3761                             $dstat !~ /^do\s*{/ &&                                      # do {...
3762                             $dstat !~ /^\({/ &&                                         # ({...
3763                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3764                         {
3765                                 $ctx =~ s/\n*$//;
3766                                 my $herectx = $here . "\n";
3767                                 my $cnt = statement_rawlines($ctx);
3768
3769                                 for (my $n = 0; $n < $cnt; $n++) {
3770                                         $herectx .= raw_line($linenr, $n) . "\n";
3771                                 }
3772
3773                                 if ($dstat =~ /;/) {
3774                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3775                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3776                                 } else {
3777                                         ERROR("COMPLEX_MACRO",
3778                                               "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3779                                 }
3780                         }
3781
3782 # check for line continuations outside of #defines, preprocessor #, and asm
3783
3784                 } else {
3785                         if ($prevline !~ /^..*\\$/ &&
3786                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
3787                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
3788                             $line =~ /^\+.*\\$/) {
3789                                 WARN("LINE_CONTINUATIONS",
3790                                      "Avoid unnecessary line continuations\n" . $herecurr);
3791                         }
3792                 }
3793
3794 # do {} while (0) macro tests:
3795 # single-statement macros do not need to be enclosed in do while (0) loop,
3796 # macro should not end with a semicolon
3797                 if ($^V && $^V ge 5.10.0 &&
3798                     $realfile !~ m@/vmlinux.lds.h$@ &&
3799                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3800                         my $ln = $linenr;
3801                         my $cnt = $realcnt;
3802                         my ($off, $dstat, $dcond, $rest);
3803                         my $ctx = '';
3804                         ($dstat, $dcond, $ln, $cnt, $off) =
3805                                 ctx_statement_block($linenr, $realcnt, 0);
3806                         $ctx = $dstat;
3807
3808                         $dstat =~ s/\\\n.//g;
3809
3810                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3811                                 my $stmts = $2;
3812                                 my $semis = $3;
3813
3814                                 $ctx =~ s/\n*$//;
3815                                 my $cnt = statement_rawlines($ctx);
3816                                 my $herectx = $here . "\n";
3817
3818                                 for (my $n = 0; $n < $cnt; $n++) {
3819                                         $herectx .= raw_line($linenr, $n) . "\n";
3820                                 }
3821
3822                                 if (($stmts =~ tr/;/;/) == 1 &&
3823                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
3824                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3825                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3826                                 }
3827                                 if (defined $semis && $semis ne "") {
3828                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3829                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3830                                 }
3831                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
3832                                 $ctx =~ s/\n*$//;
3833                                 my $cnt = statement_rawlines($ctx);
3834                                 my $herectx = $here . "\n";
3835
3836                                 for (my $n = 0; $n < $cnt; $n++) {
3837                                         $herectx .= raw_line($linenr, $n) . "\n";
3838                                 }
3839
3840                                 WARN("TRAILING_SEMICOLON",
3841                                      "macros should not use a trailing semicolon\n" . "$herectx");
3842                         }
3843                 }
3844
3845 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3846 # all assignments may have only one of the following with an assignment:
3847 #       .
3848 #       ALIGN(...)
3849 #       VMLINUX_SYMBOL(...)
3850                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3851                         WARN("MISSING_VMLINUX_SYMBOL",
3852                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3853                 }
3854
3855 # check for redundant bracing round if etc
3856                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3857                         my ($level, $endln, @chunks) =
3858                                 ctx_statement_full($linenr, $realcnt, 1);
3859                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3860                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3861                         if ($#chunks > 0 && $level == 0) {
3862                                 my @allowed = ();
3863                                 my $allow = 0;
3864                                 my $seen = 0;
3865                                 my $herectx = $here . "\n";
3866                                 my $ln = $linenr - 1;
3867                                 for my $chunk (@chunks) {
3868                                         my ($cond, $block) = @{$chunk};
3869
3870                                         # If the condition carries leading newlines, then count those as offsets.
3871                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3872                                         my $offset = statement_rawlines($whitespace) - 1;
3873
3874                                         $allowed[$allow] = 0;
3875                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3876
3877                                         # We have looked at and allowed this specific line.
3878                                         $suppress_ifbraces{$ln + $offset} = 1;
3879
3880                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3881                                         $ln += statement_rawlines($block) - 1;
3882
3883                                         substr($block, 0, length($cond), '');
3884
3885                                         $seen++ if ($block =~ /^\s*{/);
3886
3887                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3888                                         if (statement_lines($cond) > 1) {
3889                                                 #print "APW: ALLOWED: cond<$cond>\n";
3890                                                 $allowed[$allow] = 1;
3891                                         }
3892                                         if ($block =~/\b(?:if|for|while)\b/) {
3893                                                 #print "APW: ALLOWED: block<$block>\n";
3894                                                 $allowed[$allow] = 1;
3895                                         }
3896                                         if (statement_block_size($block) > 1) {
3897                                                 #print "APW: ALLOWED: lines block<$block>\n";
3898                                                 $allowed[$allow] = 1;
3899                                         }
3900                                         $allow++;
3901                                 }
3902                                 if ($seen) {
3903                                         my $sum_allowed = 0;
3904                                         foreach (@allowed) {
3905                                                 $sum_allowed += $_;
3906                                         }
3907                                         if ($sum_allowed == 0) {
3908                                                 WARN("BRACES",
3909                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
3910                                         } elsif ($sum_allowed != $allow &&
3911                                                  $seen != $allow) {
3912                                                 CHK("BRACES",
3913                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
3914                                         }
3915                                 }
3916                         }
3917                 }
3918                 if (!defined $suppress_ifbraces{$linenr - 1} &&
3919                                         $line =~ /\b(if|while|for|else)\b/) {
3920                         my $allowed = 0;
3921
3922                         # Check the pre-context.
3923                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3924                                 #print "APW: ALLOWED: pre<$1>\n";
3925                                 $allowed = 1;
3926                         }
3927
3928                         my ($level, $endln, @chunks) =
3929                                 ctx_statement_full($linenr, $realcnt, $-[0]);
3930
3931                         # Check the condition.
3932                         my ($cond, $block) = @{$chunks[0]};
3933                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3934                         if (defined $cond) {
3935                                 substr($block, 0, length($cond), '');
3936                         }
3937                         if (statement_lines($cond) > 1) {
3938                                 #print "APW: ALLOWED: cond<$cond>\n";
3939                                 $allowed = 1;
3940                         }
3941                         if ($block =~/\b(?:if|for|while)\b/) {
3942                                 #print "APW: ALLOWED: block<$block>\n";
3943                                 $allowed = 1;
3944                         }
3945                         if (statement_block_size($block) > 1) {
3946                                 #print "APW: ALLOWED: lines block<$block>\n";
3947                                 $allowed = 1;
3948                         }
3949                         # Check the post-context.
3950                         if (defined $chunks[1]) {
3951                                 my ($cond, $block) = @{$chunks[1]};
3952                                 if (defined $cond) {
3953                                         substr($block, 0, length($cond), '');
3954                                 }
3955                                 if ($block =~ /^\s*\{/) {
3956                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
3957                                         $allowed = 1;
3958                                 }
3959                         }
3960                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3961                                 my $herectx = $here . "\n";
3962                                 my $cnt = statement_rawlines($block);
3963
3964                                 for (my $n = 0; $n < $cnt; $n++) {
3965                                         $herectx .= raw_line($linenr, $n) . "\n";
3966                                 }
3967
3968                                 WARN("BRACES",
3969                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
3970                         }
3971                 }
3972
3973 # check for unnecessary blank lines around braces
3974                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
3975                         CHK("BRACES",
3976                             "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3977                 }
3978                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
3979                         CHK("BRACES",
3980                             "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3981                 }
3982
3983 # no volatiles please
3984                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3985                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3986                         WARN("VOLATILE",
3987                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3988                 }
3989
3990 # warn about #if 0
3991                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3992                         CHK("REDUNDANT_CODE",
3993                             "if this code is redundant consider removing it\n" .
3994                                 $herecurr);
3995                 }
3996
3997 # check for needless "if (<foo>) fn(<foo>)" uses
3998                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
3999                         my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4000                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4001                                 WARN('NEEDLESS_IF',
4002                                      "$1(NULL) is safe this check is probably not required\n" . $hereprev);
4003                         }
4004                 }
4005
4006 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4007                 if ($line =~ /(\b$InitAttribute\b)/) {
4008                         my $attr = $1;
4009                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4010                                 my $ptr = $1;
4011                                 my $var = $2;
4012                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4013                                       ERROR("MISPLACED_INIT",
4014                                             "$attr should be placed after $var\n" . $herecurr)) ||
4015                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4016                                       WARN("MISPLACED_INIT",
4017                                            "$attr should be placed after $var\n" . $herecurr))) &&
4018                                     $fix) {
4019                                         $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;
4020                                 }
4021                         }
4022                 }
4023
4024 # check for $InitAttributeData (ie: __initdata) with const
4025                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4026                         my $attr = $1;
4027                         $attr =~ /($InitAttributePrefix)(.*)/;
4028                         my $attr_prefix = $1;
4029                         my $attr_type = $2;
4030                         if (ERROR("INIT_ATTRIBUTE",
4031                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4032                             $fix) {
4033                                 $fixed[$linenr - 1] =~
4034                                     s/$InitAttributeData/${attr_prefix}initconst/;
4035                         }
4036                 }
4037
4038 # check for $InitAttributeConst (ie: __initconst) without const
4039                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4040                         my $attr = $1;
4041                         if (ERROR("INIT_ATTRIBUTE",
4042                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
4043                             $fix) {
4044                                 my $lead = $fixed[$linenr - 1] =~
4045                                     /(^\+\s*(?:static\s+))/;
4046                                 $lead = rtrim($1);
4047                                 $lead = "$lead " if ($lead !~ /^\+$/);
4048                                 $lead = "${lead}const ";
4049                                 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
4050                         }
4051                 }
4052
4053 # don't use __constant_<foo> functions outside of include/uapi/
4054                 if ($realfile !~ m@^include/uapi/@ &&
4055                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4056                         my $constant_func = $1;
4057                         my $func = $constant_func;
4058                         $func =~ s/^__constant_//;
4059                         if (WARN("CONSTANT_CONVERSION",
4060                                  "$constant_func should be $func\n" . $herecurr) &&
4061                             $fix) {
4062                                 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
4063                         }
4064                 }
4065
4066 # prefer usleep_range over udelay
4067                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4068                         my $delay = $1;
4069                         # ignore udelay's < 10, however
4070                         if (! ($delay < 10) ) {
4071                                 CHK("USLEEP_RANGE",
4072                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4073                         }
4074                         if ($delay > 2000) {
4075                                 WARN("LONG_UDELAY",
4076                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4077                         }
4078                 }
4079
4080 # warn about unexpectedly long msleep's
4081                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4082                         if ($1 < 20) {
4083                                 WARN("MSLEEP",
4084                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4085                         }
4086                 }
4087
4088 # check for comparisons of jiffies
4089                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4090                         WARN("JIFFIES_COMPARISON",
4091                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4092                 }
4093
4094 # check for comparisons of get_jiffies_64()
4095                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4096                         WARN("JIFFIES_COMPARISON",
4097                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4098                 }
4099
4100 # warn about #ifdefs in C files
4101 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4102 #                       print "#ifdef in C files should be avoided\n";
4103 #                       print "$herecurr";
4104 #                       $clean = 0;
4105 #               }
4106
4107 # warn about spacing in #ifdefs
4108                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4109                         if (ERROR("SPACING",
4110                                   "exactly one space required after that #$1\n" . $herecurr) &&
4111                             $fix) {
4112                                 $fixed[$linenr - 1] =~
4113                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4114                         }
4115
4116                 }
4117
4118 # check for spinlock_t definitions without a comment.
4119                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4120                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4121                         my $which = $1;
4122                         if (!ctx_has_comment($first_line, $linenr)) {
4123                                 CHK("UNCOMMENTED_DEFINITION",
4124                                     "$1 definition without comment\n" . $herecurr);
4125                         }
4126                 }
4127 # check for memory barriers without a comment.
4128                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4129                         if (!ctx_has_comment($first_line, $linenr)) {
4130                                 WARN("MEMORY_BARRIER",
4131                                      "memory barrier without comment\n" . $herecurr);
4132                         }
4133                 }
4134 # check of hardware specific defines
4135                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4136                         CHK("ARCH_DEFINES",
4137                             "architecture specific defines should be avoided\n" .  $herecurr);
4138                 }
4139
4140 # Check that the storage class is at the beginning of a declaration
4141                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4142                         WARN("STORAGE_CLASS",
4143                              "storage class should be at the beginning of the declaration\n" . $herecurr)
4144                 }
4145
4146 # check the location of the inline attribute, that it is between
4147 # storage class and type.
4148                 if ($line =~ /\b$Type\s+$Inline\b/ ||
4149                     $line =~ /\b$Inline\s+$Storage\b/) {
4150                         ERROR("INLINE_LOCATION",
4151                               "inline keyword should sit between storage class and type\n" . $herecurr);
4152                 }
4153
4154 # Check for __inline__ and __inline, prefer inline
4155                 if ($realfile !~ m@\binclude/uapi/@ &&
4156                     $line =~ /\b(__inline__|__inline)\b/) {
4157                         if (WARN("INLINE",
4158                                  "plain inline is preferred over $1\n" . $herecurr) &&
4159                             $fix) {
4160                                 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4161
4162                         }
4163                 }
4164
4165 # Check for __attribute__ packed, prefer __packed
4166                 if ($realfile !~ m@\binclude/uapi/@ &&
4167                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4168                         WARN("PREFER_PACKED",
4169                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4170                 }
4171
4172 # Check for __attribute__ aligned, prefer __aligned
4173                 if ($realfile !~ m@\binclude/uapi/@ &&
4174                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4175                         WARN("PREFER_ALIGNED",
4176                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4177                 }
4178
4179 # Check for __attribute__ format(printf, prefer __printf
4180                 if ($realfile !~ m@\binclude/uapi/@ &&
4181                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4182                         if (WARN("PREFER_PRINTF",
4183                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4184                             $fix) {
4185                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4186
4187                         }
4188                 }
4189
4190 # Check for __attribute__ format(scanf, prefer __scanf
4191                 if ($realfile !~ m@\binclude/uapi/@ &&
4192                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4193                         if (WARN("PREFER_SCANF",
4194                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4195                             $fix) {
4196                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4197                         }
4198                 }
4199
4200 # check for sizeof(&)
4201                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4202                         WARN("SIZEOF_ADDRESS",
4203                              "sizeof(& should be avoided\n" . $herecurr);
4204                 }
4205
4206 # check for sizeof without parenthesis
4207                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4208                         if (WARN("SIZEOF_PARENTHESIS",
4209                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4210                             $fix) {
4211                                 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4212                         }
4213                 }
4214
4215 # check for line continuations in quoted strings with odd counts of "
4216                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4217                         WARN("LINE_CONTINUATIONS",
4218                              "Avoid line continuations in quoted strings\n" . $herecurr);
4219                 }
4220
4221 # check for struct spinlock declarations
4222                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4223                         WARN("USE_SPINLOCK_T",
4224                              "struct spinlock should be spinlock_t\n" . $herecurr);
4225                 }
4226
4227 # check for seq_printf uses that could be seq_puts
4228                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4229                         my $fmt = get_quoted_string($line, $rawline);
4230                         if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4231                                 if (WARN("PREFER_SEQ_PUTS",
4232                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4233                                     $fix) {
4234                                         $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4235                                 }
4236                         }
4237                 }
4238
4239 # Check for misused memsets
4240                 if ($^V && $^V ge 5.10.0 &&
4241                     defined $stat &&
4242                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4243
4244                         my $ms_addr = $2;
4245                         my $ms_val = $7;
4246                         my $ms_size = $12;
4247
4248                         if ($ms_size =~ /^(0x|)0$/i) {
4249                                 ERROR("MEMSET",
4250                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4251                         } elsif ($ms_size =~ /^(0x|)1$/i) {
4252                                 WARN("MEMSET",
4253                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4254                         }
4255                 }
4256
4257 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4258                 if ($^V && $^V ge 5.10.0 &&
4259                     $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4260                         if (WARN("PREFER_ETHER_ADDR_COPY",
4261                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4262                             $fix) {
4263                                 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4264                         }
4265                 }
4266
4267 # typecasts on min/max could be min_t/max_t
4268                 if ($^V && $^V ge 5.10.0 &&
4269                     defined $stat &&
4270                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4271                         if (defined $2 || defined $7) {
4272                                 my $call = $1;
4273                                 my $cast1 = deparenthesize($2);
4274                                 my $arg1 = $3;
4275                                 my $cast2 = deparenthesize($7);
4276                                 my $arg2 = $8;
4277                                 my $cast;
4278
4279                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4280                                         $cast = "$cast1 or $cast2";
4281                                 } elsif ($cast1 ne "") {
4282                                         $cast = $cast1;
4283                                 } else {
4284                                         $cast = $cast2;
4285                                 }
4286                                 WARN("MINMAX",
4287                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4288                         }
4289                 }
4290
4291 # check usleep_range arguments
4292                 if ($^V && $^V ge 5.10.0 &&
4293                     defined $stat &&
4294                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4295                         my $min = $1;
4296                         my $max = $7;
4297                         if ($min eq $max) {
4298                                 WARN("USLEEP_RANGE",
4299                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4300                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4301                                  $min > $max) {
4302                                 WARN("USLEEP_RANGE",
4303                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4304                         }
4305                 }
4306
4307 # check for naked sscanf
4308                 if ($^V && $^V ge 5.10.0 &&
4309                     defined $stat &&
4310                     $line =~ /\bsscanf\b/ &&
4311                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4312                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4313                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4314                         my $lc = $stat =~ tr@\n@@;
4315                         $lc = $lc + $linenr;
4316                         my $stat_real = raw_line($linenr, 0);
4317                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
4318                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4319                         }
4320                         WARN("NAKED_SSCANF",
4321                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4322                 }
4323
4324 # check for simple sscanf that should be kstrto<foo>
4325                 if ($^V && $^V ge 5.10.0 &&
4326                     defined $stat &&
4327                     $line =~ /\bsscanf\b/) {
4328                         my $lc = $stat =~ tr@\n@@;
4329                         $lc = $lc + $linenr;
4330                         my $stat_real = raw_line($linenr, 0);
4331                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
4332                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4333                         }
4334                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
4335                                 my $format = $6;
4336                                 my $count = $format =~ tr@%@%@;
4337                                 if ($count == 1 &&
4338                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
4339                                         WARN("SSCANF_TO_KSTRTO",
4340                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4341                                 }
4342                         }
4343                 }
4344
4345 # check for new externs in .h files.
4346                 if ($realfile =~ /\.h$/ &&
4347                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4348                         if (CHK("AVOID_EXTERNS",
4349                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4350                             $fix) {
4351                                 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4352                         }
4353                 }
4354
4355 # check for new externs in .c files.
4356                 if ($realfile =~ /\.c$/ && defined $stat &&
4357                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4358                 {
4359                         my $function_name = $1;
4360                         my $paren_space = $2;
4361
4362                         my $s = $stat;
4363                         if (defined $cond) {
4364                                 substr($s, 0, length($cond), '');
4365                         }
4366                         if ($s =~ /^\s*;/ &&
4367                             $function_name ne 'uninitialized_var')
4368                         {
4369                                 WARN("AVOID_EXTERNS",
4370                                      "externs should be avoided in .c files\n" .  $herecurr);
4371                         }
4372
4373                         if ($paren_space =~ /\n/) {
4374                                 WARN("FUNCTION_ARGUMENTS",
4375                                      "arguments for function declarations should follow identifier\n" . $herecurr);
4376                         }
4377
4378                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4379                     $stat =~ /^.\s*extern\s+/)
4380                 {
4381                         WARN("AVOID_EXTERNS",
4382                              "externs should be avoided in .c files\n" .  $herecurr);
4383                 }
4384
4385 # checks for new __setup's
4386                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4387                         my $name = $1;
4388
4389                         if (!grep(/$name/, @setup_docs)) {
4390                                 CHK("UNDOCUMENTED_SETUP",
4391                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4392                         }
4393                 }
4394
4395 # check for pointless casting of kmalloc return
4396                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4397                         WARN("UNNECESSARY_CASTS",
4398                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4399                 }
4400
4401 # alloc style
4402 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4403                 if ($^V && $^V ge 5.10.0 &&
4404                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4405                         CHK("ALLOC_SIZEOF_STRUCT",
4406                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4407                 }
4408
4409 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4410                 if ($^V && $^V ge 5.10.0 &&
4411                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/) {
4412                         my $oldfunc = $3;
4413                         my $a1 = $4;
4414                         my $a2 = $10;
4415                         my $newfunc = "kmalloc_array";
4416                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4417                         if ($a1 =~ /^sizeof\s*\S/ || $a2 =~ /^sizeof\s*\S/) {
4418                                 if (WARN("ALLOC_WITH_MULTIPLY",
4419                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4420                                     $fix) {
4421                                         my $r1 = $a1;
4422                                         my $r2 = $a2;
4423                                         if ($a1 =~ /^sizeof\s*\S/) {
4424                                                 $r1 = $a2;
4425                                                 $r2 = $a1;
4426                                         }
4427                                         $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;
4428
4429                                 }
4430                         }
4431                 }
4432
4433 # check for krealloc arg reuse
4434                 if ($^V && $^V ge 5.10.0 &&
4435                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4436                         WARN("KREALLOC_ARG_REUSE",
4437                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4438                 }
4439
4440 # check for alloc argument mismatch
4441                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4442                         WARN("ALLOC_ARRAY_ARGS",
4443                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4444                 }
4445
4446 # check for multiple semicolons
4447                 if ($line =~ /;\s*;\s*$/) {
4448                         if (WARN("ONE_SEMICOLON",
4449                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
4450                             $fix) {
4451                                 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4452                         }
4453                 }
4454
4455 # check for case / default statements not preceeded by break/fallthrough/switch
4456                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4457                         my $has_break = 0;
4458                         my $has_statement = 0;
4459                         my $count = 0;
4460                         my $prevline = $linenr;
4461                         while ($prevline > 1 && $count < 3 && !$has_break) {
4462                                 $prevline--;
4463                                 my $rline = $rawlines[$prevline - 1];
4464                                 my $fline = $lines[$prevline - 1];
4465                                 last if ($fline =~ /^\@\@/);
4466                                 next if ($fline =~ /^\-/);
4467                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4468                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4469                                 next if ($fline =~ /^.[\s$;]*$/);
4470                                 $has_statement = 1;
4471                                 $count++;
4472                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4473                         }
4474                         if (!$has_break && $has_statement) {
4475                                 WARN("MISSING_BREAK",
4476                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4477                         }
4478                 }
4479
4480 # check for switch/default statements without a break;
4481                 if ($^V && $^V ge 5.10.0 &&
4482                     defined $stat &&
4483                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4484                         my $ctx = '';
4485                         my $herectx = $here . "\n";
4486                         my $cnt = statement_rawlines($stat);
4487                         for (my $n = 0; $n < $cnt; $n++) {
4488                                 $herectx .= raw_line($linenr, $n) . "\n";
4489                         }
4490                         WARN("DEFAULT_NO_BREAK",
4491                              "switch default: should use break\n" . $herectx);
4492                 }
4493
4494 # check for gcc specific __FUNCTION__
4495                 if ($line =~ /\b__FUNCTION__\b/) {
4496                         if (WARN("USE_FUNC",
4497                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
4498                             $fix) {
4499                                 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4500                         }
4501                 }
4502
4503 # check for use of yield()
4504                 if ($line =~ /\byield\s*\(\s*\)/) {
4505                         WARN("YIELD",
4506                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
4507                 }
4508
4509 # check for comparisons against true and false
4510                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4511                         my $lead = $1;
4512                         my $arg = $2;
4513                         my $test = $3;
4514                         my $otype = $4;
4515                         my $trail = $5;
4516                         my $op = "!";
4517
4518                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4519
4520                         my $type = lc($otype);
4521                         if ($type =~ /^(?:true|false)$/) {
4522                                 if (("$test" eq "==" && "$type" eq "true") ||
4523                                     ("$test" eq "!=" && "$type" eq "false")) {
4524                                         $op = "";
4525                                 }
4526
4527                                 CHK("BOOL_COMPARISON",
4528                                     "Using comparison to $otype is error prone\n" . $herecurr);
4529
4530 ## maybe suggesting a correct construct would better
4531 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4532
4533                         }
4534                 }
4535
4536 # check for semaphores initialized locked
4537                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4538                         WARN("CONSIDER_COMPLETION",
4539                              "consider using a completion\n" . $herecurr);
4540                 }
4541
4542 # recommend kstrto* over simple_strto* and strict_strto*
4543                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4544                         WARN("CONSIDER_KSTRTO",
4545                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
4546                 }
4547
4548 # check for __initcall(), use device_initcall() explicitly please
4549                 if ($line =~ /^.\s*__initcall\s*\(/) {
4550                         WARN("USE_DEVICE_INITCALL",
4551                              "please use device_initcall() instead of __initcall()\n" . $herecurr);
4552                 }
4553
4554 # check for various ops structs, ensure they are const.
4555                 my $struct_ops = qr{acpi_dock_ops|
4556                                 address_space_operations|
4557                                 backlight_ops|
4558                                 block_device_operations|
4559                                 dentry_operations|
4560                                 dev_pm_ops|
4561                                 dma_map_ops|
4562                                 extent_io_ops|
4563                                 file_lock_operations|
4564                                 file_operations|
4565                                 hv_ops|
4566                                 ide_dma_ops|
4567                                 intel_dvo_dev_ops|
4568                                 item_operations|
4569                                 iwl_ops|
4570                                 kgdb_arch|
4571                                 kgdb_io|
4572                                 kset_uevent_ops|
4573                                 lock_manager_operations|
4574                                 microcode_ops|
4575                                 mtrr_ops|
4576                                 neigh_ops|
4577                                 nlmsvc_binding|
4578                                 pci_raw_ops|
4579                                 pipe_buf_operations|
4580                                 platform_hibernation_ops|
4581                                 platform_suspend_ops|
4582                                 proto_ops|
4583                                 rpc_pipe_ops|
4584                                 seq_operations|
4585                                 snd_ac97_build_ops|
4586                                 soc_pcmcia_socket_ops|
4587                                 stacktrace_ops|
4588                                 sysfs_ops|
4589                                 tty_operations|
4590                                 usb_mon_operations|
4591                                 wd_ops}x;
4592                 if ($line !~ /\bconst\b/ &&
4593                     $line =~ /\bstruct\s+($struct_ops)\b/) {
4594                         WARN("CONST_STRUCT",
4595                              "struct $1 should normally be const\n" .
4596                                 $herecurr);
4597                 }
4598
4599 # use of NR_CPUS is usually wrong
4600 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4601                 if ($line =~ /\bNR_CPUS\b/ &&
4602                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4603                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4604                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4605                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4606                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4607                 {
4608                         WARN("NR_CPUS",
4609                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4610                 }
4611
4612 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4613                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4614                         ERROR("DEFINE_ARCH_HAS",
4615                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4616                 }
4617
4618 # check for %L{u,d,i} in strings
4619                 my $string;
4620                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4621                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4622                         $string =~ s/%%/__/g;
4623                         if ($string =~ /(?<!%)%L[udi]/) {
4624                                 WARN("PRINTF_L",
4625                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4626                                 last;
4627                         }
4628                 }
4629
4630 # whine mightly about in_atomic
4631                 if ($line =~ /\bin_atomic\s*\(/) {
4632                         if ($realfile =~ m@^drivers/@) {
4633                                 ERROR("IN_ATOMIC",
4634                                       "do not use in_atomic in drivers\n" . $herecurr);
4635                         } elsif ($realfile !~ m@^kernel/@) {
4636                                 WARN("IN_ATOMIC",
4637                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4638                         }
4639                 }
4640
4641 # check for lockdep_set_novalidate_class
4642                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4643                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
4644                         if ($realfile !~ m@^kernel/lockdep@ &&
4645                             $realfile !~ m@^include/linux/lockdep@ &&
4646                             $realfile !~ m@^drivers/base/core@) {
4647                                 ERROR("LOCKDEP",
4648                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4649                         }
4650                 }
4651
4652                 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4653                     $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4654                         WARN("EXPORTED_WORLD_WRITABLE",
4655                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4656                 }
4657
4658 # Mode permission misuses where it seems decimal should be octal
4659 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
4660                 if ($^V && $^V ge 5.10.0 &&
4661                     $line =~ /$mode_perms_search/) {
4662                         foreach my $entry (@mode_permission_funcs) {
4663                                 my $func = $entry->[0];
4664                                 my $arg_pos = $entry->[1];
4665
4666                                 my $skip_args = "";
4667                                 if ($arg_pos > 1) {
4668                                         $arg_pos--;
4669                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4670                                 }
4671                                 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4672                                 if ($line =~ /$test/) {
4673                                         my $val = $1;
4674                                         $val = $6 if ($skip_args ne "");
4675
4676                                         if ($val !~ /^0$/ &&
4677                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4678                                              length($val) ne 4)) {
4679                                                 ERROR("NON_OCTAL_PERMISSIONS",
4680                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4681                                         }
4682                                 }
4683                         }
4684                 }
4685         }
4686
4687         # If we have no input at all, then there is nothing to report on
4688         # so just keep quiet.
4689         if ($#rawlines == -1) {
4690                 exit(0);
4691         }
4692
4693         # In mailback mode only produce a report in the negative, for
4694         # things that appear to be patches.
4695         if ($mailback && ($clean == 1 || !$is_patch)) {
4696                 exit(0);
4697         }
4698
4699         # This is not a patch, and we are are in 'no-patch' mode so
4700         # just keep quiet.
4701         if (!$chk_patch && !$is_patch) {
4702                 exit(0);
4703         }
4704
4705         if (!$is_patch) {
4706                 ERROR("NOT_UNIFIED_DIFF",
4707                       "Does not appear to be a unified-diff format patch\n");
4708         }
4709         if ($is_patch && $chk_signoff && $signoff == 0) {
4710                 ERROR("MISSING_SIGN_OFF",
4711                       "Missing Signed-off-by: line(s)\n");
4712         }
4713
4714         print report_dump();
4715         if ($summary && !($clean == 1 && $quiet == 1)) {
4716                 print "$filename " if ($summary_file);
4717                 print "total: $cnt_error errors, $cnt_warn warnings, " .
4718                         (($check)? "$cnt_chk checks, " : "") .
4719                         "$cnt_lines lines checked\n";
4720                 print "\n" if ($quiet == 0);
4721         }
4722
4723         if ($quiet == 0) {
4724
4725                 if ($^V lt 5.10.0) {
4726                         print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4727                         print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4728                 }
4729
4730                 # If there were whitespace errors which cleanpatch can fix
4731                 # then suggest that.
4732                 if ($rpt_cleaners) {
4733                         print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4734                         print "      scripts/cleanfile\n\n";
4735                         $rpt_cleaners = 0;
4736                 }
4737         }
4738
4739         hash_show_words(\%use_type, "Used");
4740         hash_show_words(\%ignore_type, "Ignored");
4741
4742         if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4743                 my $newfile = $filename;
4744                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4745                 my $linecount = 0;
4746                 my $f;
4747
4748                 open($f, '>', $newfile)
4749                     or die "$P: Can't open $newfile for write\n";
4750                 foreach my $fixed_line (@fixed) {
4751                         $linecount++;
4752                         if ($file) {
4753                                 if ($linecount > 3) {
4754                                         $fixed_line =~ s/^\+//;
4755                                         print $f $fixed_line. "\n";
4756                                 }
4757                         } else {
4758                                 print $f $fixed_line . "\n";
4759                         }
4760                 }
4761                 close($f);
4762
4763                 if (!$quiet) {
4764                         print << "EOM";
4765 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4766
4767 Do _NOT_ trust the results written to this file.
4768 Do _NOT_ submit these changes without inspecting them for correctness.
4769
4770 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4771 No warranties, expressed or implied...
4772
4773 EOM
4774                 }
4775         }
4776
4777         if ($clean == 1 && $quiet == 0) {
4778                 print "$vname has no obvious style problems and is ready for submission.\n"
4779         }
4780         if ($clean == 0 && $quiet == 0) {
4781                 print << "EOM";
4782 $vname has style problems, please review.
4783
4784 If any of these errors are false positives, please report
4785 them to the maintainer, see CHECKPATCH in MAINTAINERS.
4786 EOM
4787         }
4788
4789         return $clean;
4790 }