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