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