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