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