scripts/checkpatch.pl

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