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