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