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                                 #   :   when part of a bitfield
3142                                 } elsif ($opv eq ':B') {
3143                                         # skip the bitfield test for now
3144
3145                                 # No spaces for:
3146                                 #   ->
3147                                 } elsif ($op eq '->') {
3148                                         if ($ctx =~ /Wx.|.xW/) {
3149                                                 if (ERROR("SPACING",
3150                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3151                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3152                                                         if (defined $fix_elements[$n + 2]) {
3153                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3154                                                         }
3155                                                         $line_fixed = 1;
3156                                                 }
3157                                         }
3158
3159                                 # , must have a space on the right.
3160                                 } elsif ($op eq ',') {
3161                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3162                                                 if (ERROR("SPACING",
3163                                                           "space required after that '$op' $at\n" . $hereptr)) {
3164                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3165                                                         $line_fixed = 1;
3166                                                         $last_after = $n;
3167                                                 }
3168                                         }
3169
3170                                 # '*' as part of a type definition -- reported already.
3171                                 } elsif ($opv eq '*_') {
3172                                         #warn "'*' is part of type\n";
3173
3174                                 # unary operators should have a space before and
3175                                 # none after.  May be left adjacent to another
3176                                 # unary operator, or a cast
3177                                 } elsif ($op eq '!' || $op eq '~' ||
3178                                          $opv eq '*U' || $opv eq '-U' ||
3179                                          $opv eq '&U' || $opv eq '&&U') {
3180                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3181                                                 if (ERROR("SPACING",
3182                                                           "space required before that '$op' $at\n" . $hereptr)) {
3183                                                         if ($n != $last_after + 2) {
3184                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3185                                                                 $line_fixed = 1;
3186                                                         }
3187                                                 }
3188                                         }
3189                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3190                                                 # A unary '*' may be const
3191
3192                                         } elsif ($ctx =~ /.xW/) {
3193                                                 if (ERROR("SPACING",
3194                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3195                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3196                                                         if (defined $fix_elements[$n + 2]) {
3197                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3198                                                         }
3199                                                         $line_fixed = 1;
3200                                                 }
3201                                         }
3202
3203                                 # unary ++ and unary -- are allowed no space on one side.
3204                                 } elsif ($op eq '++' or $op eq '--') {
3205                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3206                                                 if (ERROR("SPACING",
3207                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
3208                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3209                                                         $line_fixed = 1;
3210                                                 }
3211                                         }
3212                                         if ($ctx =~ /Wx[BE]/ ||
3213                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3214                                                 if (ERROR("SPACING",
3215                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3216                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3217                                                         $line_fixed = 1;
3218                                                 }
3219                                         }
3220                                         if ($ctx =~ /ExW/) {
3221                                                 if (ERROR("SPACING",
3222                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3223                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3224                                                         if (defined $fix_elements[$n + 2]) {
3225                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3226                                                         }
3227                                                         $line_fixed = 1;
3228                                                 }
3229                                         }
3230
3231                                 # << and >> may either have or not have spaces both sides
3232                                 } elsif ($op eq '<<' or $op eq '>>' or
3233                                          $op eq '&' or $op eq '^' or $op eq '|' or
3234                                          $op eq '+' or $op eq '-' or
3235                                          $op eq '*' or $op eq '/' or
3236                                          $op eq '%')
3237                                 {
3238                                         if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3239                                                 if (ERROR("SPACING",
3240                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
3241                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3242                                                         if (defined $fix_elements[$n + 2]) {
3243                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3244                                                         }
3245                                                         $line_fixed = 1;
3246                                                 }
3247                                         }
3248
3249                                 # A colon needs no spaces before when it is
3250                                 # terminating a case value or a label.
3251                                 } elsif ($opv eq ':C' || $opv eq ':L') {
3252                                         if ($ctx =~ /Wx./) {
3253                                                 if (ERROR("SPACING",
3254                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3255                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3256                                                         $line_fixed = 1;
3257                                                 }
3258                                         }
3259
3260                                 # All the others need spaces both sides.
3261                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3262                                         my $ok = 0;
3263
3264                                         # Ignore email addresses <foo@bar>
3265                                         if (($op eq '<' &&
3266                                              $cc =~ /^\S+\@\S+>/) ||
3267                                             ($op eq '>' &&
3268                                              $ca =~ /<\S+\@\S+$/))
3269                                         {
3270                                                 $ok = 1;
3271                                         }
3272
3273                                         # messages are ERROR, but ?: are CHK
3274                                         if ($ok == 0) {
3275                                                 my $msg_type = \&ERROR;
3276                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3277
3278                                                 if (&{$msg_type}("SPACING",
3279                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {
3280                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3281                                                         if (defined $fix_elements[$n + 2]) {
3282                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3283                                                         }
3284                                                         $line_fixed = 1;
3285                                                 }
3286                                         }
3287                                 }
3288                                 $off += length($elements[$n + 1]);
3289
3290 ##                              print("n: <$n> GOOD: <$good>\n");
3291
3292                                 $fixed_line = $fixed_line . $good;
3293                         }
3294
3295                         if (($#elements % 2) == 0) {
3296                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
3297                         }
3298
3299                         if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3300                                 $fixed[$linenr - 1] = $fixed_line;
3301                         }
3302
3303
3304                 }
3305
3306 # check for whitespace before a non-naked semicolon
3307                 if ($line =~ /^\+.*\S\s+;\s*$/) {
3308                         if (WARN("SPACING",
3309                                  "space prohibited before semicolon\n" . $herecurr) &&
3310                             $fix) {
3311                                 1 while $fixed[$linenr - 1] =~
3312                                     s/^(\+.*\S)\s+;/$1;/;
3313                         }
3314                 }
3315
3316 # check for multiple assignments
3317                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3318                         CHK("MULTIPLE_ASSIGNMENTS",
3319                             "multiple assignments should be avoided\n" . $herecurr);
3320                 }
3321
3322 ## # check for multiple declarations, allowing for a function declaration
3323 ## # continuation.
3324 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3325 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3326 ##
3327 ##                      # Remove any bracketed sections to ensure we do not
3328 ##                      # falsly report the parameters of functions.
3329 ##                      my $ln = $line;
3330 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
3331 ##                      }
3332 ##                      if ($ln =~ /,/) {
3333 ##                              WARN("MULTIPLE_DECLARATION",
3334 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
3335 ##                      }
3336 ##              }
3337
3338 #need space before brace following if, while, etc
3339                 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3340                     $line =~ /do{/) {
3341                         if (ERROR("SPACING",
3342                                   "space required before the open brace '{'\n" . $herecurr) &&
3343                             $fix) {
3344                                 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3345                         }
3346                 }
3347
3348 ## # check for blank lines before declarations
3349 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3350 ##                  $prevrawline =~ /^.\s*$/) {
3351 ##                      WARN("SPACING",
3352 ##                           "No blank lines before declarations\n" . $hereprev);
3353 ##              }
3354 ##
3355
3356 # closing brace should have a space following it when it has anything
3357 # on the line
3358                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3359                         if (ERROR("SPACING",
3360                                   "space required after that close brace '}'\n" . $herecurr) &&
3361                             $fix) {
3362                                 $fixed[$linenr - 1] =~
3363                                     s/}((?!(?:,|;|\)))\S)/} $1/;
3364                         }
3365                 }
3366
3367 # check spacing on square brackets
3368                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3369                         if (ERROR("SPACING",
3370                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
3371                             $fix) {
3372                                 $fixed[$linenr - 1] =~
3373                                     s/\[\s+/\[/;
3374                         }
3375                 }
3376                 if ($line =~ /\s\]/) {
3377                         if (ERROR("SPACING",
3378                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3379                             $fix) {
3380                                 $fixed[$linenr - 1] =~
3381                                     s/\s+\]/\]/;
3382                         }
3383                 }
3384
3385 # check spacing on parentheses
3386                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3387                     $line !~ /for\s*\(\s+;/) {
3388                         if (ERROR("SPACING",
3389                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3390                             $fix) {
3391                                 $fixed[$linenr - 1] =~
3392                                     s/\(\s+/\(/;
3393                         }
3394                 }
3395                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3396                     $line !~ /for\s*\(.*;\s+\)/ &&
3397                     $line !~ /:\s+\)/) {
3398                         if (ERROR("SPACING",
3399                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3400                             $fix) {
3401                                 $fixed[$linenr - 1] =~
3402                                     s/\s+\)/\)/;
3403                         }
3404                 }
3405
3406 #goto labels aren't indented, allow a single space however
3407                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3408                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3409                         if (WARN("INDENTED_LABEL",
3410                                  "labels should not be indented\n" . $herecurr) &&
3411                             $fix) {
3412                                 $fixed[$linenr - 1] =~
3413                                     s/^(.)\s+/$1/;
3414                         }
3415                 }
3416
3417 # return is not a function
3418                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3419                         my $spacing = $1;
3420                         if ($^V && $^V ge 5.10.0 &&
3421                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3422                                 my $value = $1;
3423                                 $value = deparenthesize($value);
3424                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3425                                         ERROR("RETURN_PARENTHESES",
3426                                               "return is not a function, parentheses are not required\n" . $herecurr);
3427                                 }
3428                         } elsif ($spacing !~ /\s+/) {
3429                                 ERROR("SPACING",
3430                                       "space required before the open parenthesis '('\n" . $herecurr);
3431                         }
3432                 }
3433
3434 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3435                 if ($^V && $^V ge 5.10.0 &&
3436                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
3437                         my $openparens = $1;
3438                         my $count = $openparens =~ tr@\(@\(@;
3439                         my $msg = "";
3440                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3441                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
3442                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
3443                                 WARN("UNNECESSARY_PARENTHESES",
3444                                      "Unnecessary parentheses$msg\n" . $herecurr);
3445                         }
3446                 }
3447
3448 # Return of what appears to be an errno should normally be -'ve
3449                 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3450                         my $name = $1;
3451                         if ($name ne 'EOF' && $name ne 'ERROR') {
3452                                 WARN("USE_NEGATIVE_ERRNO",
3453                                      "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3454                         }
3455                 }
3456
3457 # Need a space before open parenthesis after if, while etc
3458                 if ($line =~ /\b(if|while|for|switch)\(/) {
3459                         if (ERROR("SPACING",
3460                                   "space required before the open parenthesis '('\n" . $herecurr) &&
3461                             $fix) {
3462                                 $fixed[$linenr - 1] =~
3463                                     s/\b(if|while|for|switch)\(/$1 \(/;
3464                         }
3465                 }
3466
3467 # Check for illegal assignment in if conditional -- and check for trailing
3468 # statements after the conditional.
3469                 if ($line =~ /do\s*(?!{)/) {
3470                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3471                                 ctx_statement_block($linenr, $realcnt, 0)
3472                                         if (!defined $stat);
3473                         my ($stat_next) = ctx_statement_block($line_nr_next,
3474                                                 $remain_next, $off_next);
3475                         $stat_next =~ s/\n./\n /g;
3476                         ##print "stat<$stat> stat_next<$stat_next>\n";
3477
3478                         if ($stat_next =~ /^\s*while\b/) {
3479                                 # If the statement carries leading newlines,
3480                                 # then count those as offsets.
3481                                 my ($whitespace) =
3482                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3483                                 my $offset =
3484                                         statement_rawlines($whitespace) - 1;
3485
3486                                 $suppress_whiletrailers{$line_nr_next +
3487                                                                 $offset} = 1;
3488                         }
3489                 }
3490                 if (!defined $suppress_whiletrailers{$linenr} &&
3491                     defined($stat) && defined($cond) &&
3492                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3493                         my ($s, $c) = ($stat, $cond);
3494
3495                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3496                                 ERROR("ASSIGN_IN_IF",
3497                                       "do not use assignment in if condition\n" . $herecurr);
3498                         }
3499
3500                         # Find out what is on the end of the line after the
3501                         # conditional.
3502                         substr($s, 0, length($c), '');
3503                         $s =~ s/\n.*//g;
3504                         $s =~ s/$;//g;  # Remove any comments
3505                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3506                             $c !~ /}\s*while\s*/)
3507                         {
3508                                 # Find out how long the conditional actually is.
3509                                 my @newlines = ($c =~ /\n/gs);
3510                                 my $cond_lines = 1 + $#newlines;
3511                                 my $stat_real = '';
3512
3513                                 $stat_real = raw_line($linenr, $cond_lines)
3514                                                         . "\n" if ($cond_lines);
3515                                 if (defined($stat_real) && $cond_lines > 1) {
3516                                         $stat_real = "[...]\n$stat_real";
3517                                 }
3518
3519                                 ERROR("TRAILING_STATEMENTS",
3520                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
3521                         }
3522                 }
3523
3524 # Check for bitwise tests written as boolean
3525                 if ($line =~ /
3526                         (?:
3527                                 (?:\[|\(|\&\&|\|\|)
3528                                 \s*0[xX][0-9]+\s*
3529                                 (?:\&\&|\|\|)
3530                         |
3531                                 (?:\&\&|\|\|)
3532                                 \s*0[xX][0-9]+\s*
3533                                 (?:\&\&|\|\||\)|\])
3534                         )/x)
3535                 {
3536                         WARN("HEXADECIMAL_BOOLEAN_TEST",
3537                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3538                 }
3539
3540 # if and else should not have general statements after it
3541                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3542                         my $s = $1;
3543                         $s =~ s/$;//g;  # Remove any comments
3544                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3545                                 ERROR("TRAILING_STATEMENTS",
3546                                       "trailing statements should be on next line\n" . $herecurr);
3547                         }
3548                 }
3549 # if should not continue a brace
3550                 if ($line =~ /}\s*if\b/) {
3551                         ERROR("TRAILING_STATEMENTS",
3552                               "trailing statements should be on next line\n" .
3553                                 $herecurr);
3554                 }
3555 # case and default should not have general statements after them
3556                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3557                     $line !~ /\G(?:
3558                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3559                         \s*return\s+
3560                     )/xg)
3561                 {
3562                         ERROR("TRAILING_STATEMENTS",
3563                               "trailing statements should be on next line\n" . $herecurr);
3564                 }
3565
3566                 # Check for }<nl>else {, these must be at the same
3567                 # indent level to be relevant to each other.
3568                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3569                                                 $previndent == $indent) {
3570                         ERROR("ELSE_AFTER_BRACE",
3571                               "else should follow close brace '}'\n" . $hereprev);
3572                 }
3573
3574                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3575                                                 $previndent == $indent) {
3576                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3577
3578                         # Find out what is on the end of the line after the
3579                         # conditional.
3580                         substr($s, 0, length($c), '');
3581                         $s =~ s/\n.*//g;
3582
3583                         if ($s =~ /^\s*;/) {
3584                                 ERROR("WHILE_AFTER_BRACE",
3585                                       "while should follow close brace '}'\n" . $hereprev);
3586                         }
3587                 }
3588
3589 #Specific variable tests
3590                 while ($line =~ m{($Constant|$Lval)}g) {
3591                         my $var = $1;
3592
3593 #gcc binary extension
3594                         if ($var =~ /^$Binary$/) {
3595                                 if (WARN("GCC_BINARY_CONSTANT",
3596                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3597                                     $fix) {
3598                                         my $hexval = sprintf("0x%x", oct($var));
3599                                         $fixed[$linenr - 1] =~
3600                                             s/\b$var\b/$hexval/;
3601                                 }
3602                         }
3603
3604 #CamelCase
3605                         if ($var !~ /^$Constant$/ &&
3606                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3607 #Ignore Page<foo> variants
3608                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3609 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3610                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3611                                 while ($var =~ m{($Ident)}g) {
3612                                         my $word = $1;
3613                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3614                                         if ($check) {
3615                                                 seed_camelcase_includes();
3616                                                 if (!$file && !$camelcase_file_seeded) {
3617                                                         seed_camelcase_file($realfile);
3618                                                         $camelcase_file_seeded = 1;
3619                                                 }
3620                                         }
3621                                         if (!defined $camelcase{$word}) {
3622                                                 $camelcase{$word} = 1;
3623                                                 CHK("CAMELCASE",
3624                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
3625                                         }
3626                                 }
3627                         }
3628                 }
3629
3630 #no spaces allowed after \ in define
3631                 if ($line =~ /\#\s*define.*\\\s+$/) {
3632                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3633                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3634                             $fix) {
3635                                 $fixed[$linenr - 1] =~ s/\s+$//;
3636                         }
3637                 }
3638
3639 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3640                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3641                         my $file = "$1.h";
3642                         my $checkfile = "include/linux/$file";
3643                         if (-f "$root/$checkfile" &&
3644                             $realfile ne $checkfile &&
3645                             $1 !~ /$allowed_asm_includes/)
3646                         {
3647                                 if ($realfile =~ m{^arch/}) {
3648                                         CHK("ARCH_INCLUDE_LINUX",
3649                                             "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3650                                 } else {
3651                                         WARN("INCLUDE_LINUX",
3652                                              "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3653                                 }
3654                         }
3655                 }
3656
3657 # multi-statement macros should be enclosed in a do while loop, grab the
3658 # first statement and ensure its the whole macro if its not enclosed
3659 # in a known good container
3660                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3661                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3662                         my $ln = $linenr;
3663                         my $cnt = $realcnt;
3664                         my ($off, $dstat, $dcond, $rest);
3665                         my $ctx = '';
3666                         ($dstat, $dcond, $ln, $cnt, $off) =
3667                                 ctx_statement_block($linenr, $realcnt, 0);
3668                         $ctx = $dstat;
3669                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3670                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3671
3672                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3673                         $dstat =~ s/$;//g;
3674                         $dstat =~ s/\\\n.//g;
3675                         $dstat =~ s/^\s*//s;
3676                         $dstat =~ s/\s*$//s;
3677
3678                         # Flatten any parentheses and braces
3679                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3680                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
3681                                $dstat =~ s/\[[^\[\]]*\]/1/)
3682                         {
3683                         }
3684
3685                         # Flatten any obvious string concatentation.
3686                         while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3687                                $dstat =~ s/$Ident\s*("X*")/$1/)
3688                         {
3689                         }
3690
3691                         my $exceptions = qr{
3692                                 $Declare|
3693                                 module_param_named|
3694                                 MODULE_PARM_DESC|
3695                                 DECLARE_PER_CPU|
3696                                 DEFINE_PER_CPU|
3697                                 __typeof__\(|
3698                                 union|
3699                                 struct|
3700                                 \.$Ident\s*=\s*|
3701                                 ^\"|\"$
3702                         }x;
3703                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3704                         if ($dstat ne '' &&
3705                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
3706                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
3707                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3708                             $dstat !~ /^'X'$/ &&                                        # character constants
3709                             $dstat !~ /$exceptions/ &&
3710                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
3711                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
3712                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
3713                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
3714                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
3715                             $dstat !~ /^do\s*{/ &&                                      # do {...
3716                             $dstat !~ /^\({/ &&                                         # ({...
3717                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3718                         {
3719                                 $ctx =~ s/\n*$//;
3720                                 my $herectx = $here . "\n";
3721                                 my $cnt = statement_rawlines($ctx);
3722
3723                                 for (my $n = 0; $n < $cnt; $n++) {
3724                                         $herectx .= raw_line($linenr, $n) . "\n";
3725                                 }
3726
3727                                 if ($dstat =~ /;/) {
3728                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3729                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3730                                 } else {
3731                                         ERROR("COMPLEX_MACRO",
3732                                               "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3733                                 }
3734                         }
3735
3736 # check for line continuations outside of #defines, preprocessor #, and asm
3737
3738                 } else {
3739                         if ($prevline !~ /^..*\\$/ &&
3740                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
3741                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
3742                             $line =~ /^\+.*\\$/) {
3743                                 WARN("LINE_CONTINUATIONS",
3744                                      "Avoid unnecessary line continuations\n" . $herecurr);
3745                         }
3746                 }
3747
3748 # do {} while (0) macro tests:
3749 # single-statement macros do not need to be enclosed in do while (0) loop,
3750 # macro should not end with a semicolon
3751                 if ($^V && $^V ge 5.10.0 &&
3752                     $realfile !~ m@/vmlinux.lds.h$@ &&
3753                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3754                         my $ln = $linenr;
3755                         my $cnt = $realcnt;
3756                         my ($off, $dstat, $dcond, $rest);
3757                         my $ctx = '';
3758                         ($dstat, $dcond, $ln, $cnt, $off) =
3759                                 ctx_statement_block($linenr, $realcnt, 0);
3760                         $ctx = $dstat;
3761
3762                         $dstat =~ s/\\\n.//g;
3763
3764                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3765                                 my $stmts = $2;
3766                                 my $semis = $3;
3767
3768                                 $ctx =~ s/\n*$//;
3769                                 my $cnt = statement_rawlines($ctx);
3770                                 my $herectx = $here . "\n";
3771
3772                                 for (my $n = 0; $n < $cnt; $n++) {
3773                                         $herectx .= raw_line($linenr, $n) . "\n";
3774                                 }
3775
3776                                 if (($stmts =~ tr/;/;/) == 1 &&
3777                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
3778                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3779                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3780                                 }
3781                                 if (defined $semis && $semis ne "") {
3782                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3783                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3784                                 }
3785                         }
3786                 }
3787
3788 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3789 # all assignments may have only one of the following with an assignment:
3790 #       .
3791 #       ALIGN(...)
3792 #       VMLINUX_SYMBOL(...)
3793                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3794                         WARN("MISSING_VMLINUX_SYMBOL",
3795                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3796                 }
3797
3798 # check for redundant bracing round if etc
3799                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3800                         my ($level, $endln, @chunks) =
3801                                 ctx_statement_full($linenr, $realcnt, 1);
3802                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3803                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3804                         if ($#chunks > 0 && $level == 0) {
3805                                 my @allowed = ();
3806                                 my $allow = 0;
3807                                 my $seen = 0;
3808                                 my $herectx = $here . "\n";
3809                                 my $ln = $linenr - 1;
3810                                 for my $chunk (@chunks) {
3811                                         my ($cond, $block) = @{$chunk};
3812
3813                                         # If the condition carries leading newlines, then count those as offsets.
3814                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3815                                         my $offset = statement_rawlines($whitespace) - 1;
3816
3817                                         $allowed[$allow] = 0;
3818                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3819
3820                                         # We have looked at and allowed this specific line.
3821                                         $suppress_ifbraces{$ln + $offset} = 1;
3822
3823                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3824                                         $ln += statement_rawlines($block) - 1;
3825
3826                                         substr($block, 0, length($cond), '');
3827
3828                                         $seen++ if ($block =~ /^\s*{/);
3829
3830                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3831                                         if (statement_lines($cond) > 1) {
3832                                                 #print "APW: ALLOWED: cond<$cond>\n";
3833                                                 $allowed[$allow] = 1;
3834                                         }
3835                                         if ($block =~/\b(?:if|for|while)\b/) {
3836                                                 #print "APW: ALLOWED: block<$block>\n";
3837                                                 $allowed[$allow] = 1;
3838                                         }
3839                                         if (statement_block_size($block) > 1) {
3840                                                 #print "APW: ALLOWED: lines block<$block>\n";
3841                                                 $allowed[$allow] = 1;
3842                                         }
3843                                         $allow++;
3844                                 }
3845                                 if ($seen) {
3846                                         my $sum_allowed = 0;
3847                                         foreach (@allowed) {
3848                                                 $sum_allowed += $_;
3849                                         }
3850                                         if ($sum_allowed == 0) {
3851                                                 WARN("BRACES",
3852                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
3853                                         } elsif ($sum_allowed != $allow &&
3854                                                  $seen != $allow) {
3855                                                 CHK("BRACES",
3856                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
3857                                         }
3858                                 }
3859                         }
3860                 }
3861                 if (!defined $suppress_ifbraces{$linenr - 1} &&
3862                                         $line =~ /\b(if|while|for|else)\b/) {
3863                         my $allowed = 0;
3864
3865                         # Check the pre-context.
3866                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3867                                 #print "APW: ALLOWED: pre<$1>\n";
3868                                 $allowed = 1;
3869                         }
3870
3871                         my ($level, $endln, @chunks) =
3872                                 ctx_statement_full($linenr, $realcnt, $-[0]);
3873
3874                         # Check the condition.
3875                         my ($cond, $block) = @{$chunks[0]};
3876                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3877                         if (defined $cond) {
3878                                 substr($block, 0, length($cond), '');
3879                         }
3880                         if (statement_lines($cond) > 1) {
3881                                 #print "APW: ALLOWED: cond<$cond>\n";
3882                                 $allowed = 1;
3883                         }
3884                         if ($block =~/\b(?:if|for|while)\b/) {
3885                                 #print "APW: ALLOWED: block<$block>\n";
3886                                 $allowed = 1;
3887                         }
3888                         if (statement_block_size($block) > 1) {
3889                                 #print "APW: ALLOWED: lines block<$block>\n";
3890                                 $allowed = 1;
3891                         }
3892                         # Check the post-context.
3893                         if (defined $chunks[1]) {
3894                                 my ($cond, $block) = @{$chunks[1]};
3895                                 if (defined $cond) {
3896                                         substr($block, 0, length($cond), '');
3897                                 }
3898                                 if ($block =~ /^\s*\{/) {
3899                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
3900                                         $allowed = 1;
3901                                 }
3902                         }
3903                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3904                                 my $herectx = $here . "\n";
3905                                 my $cnt = statement_rawlines($block);
3906
3907                                 for (my $n = 0; $n < $cnt; $n++) {
3908                                         $herectx .= raw_line($linenr, $n) . "\n";
3909                                 }
3910
3911                                 WARN("BRACES",
3912                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
3913                         }
3914                 }
3915
3916 # check for unnecessary blank lines around braces
3917                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
3918                         CHK("BRACES",
3919                             "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3920                 }
3921                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
3922                         CHK("BRACES",
3923                             "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3924                 }
3925
3926 # no volatiles please
3927                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3928                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3929                         WARN("VOLATILE",
3930                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3931                 }
3932
3933 # warn about #if 0
3934                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3935                         CHK("REDUNDANT_CODE",
3936                             "if this code is redundant consider removing it\n" .
3937                                 $herecurr);
3938                 }
3939
3940 # check for needless "if (<foo>) fn(<foo>)" uses
3941                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
3942                         my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
3943                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
3944                                 WARN('NEEDLESS_IF',
3945                                      "$1(NULL) is safe this check is probably not required\n" . $hereprev);
3946                         }
3947                 }
3948
3949 # check for bad placement of section $InitAttribute (e.g.: __initdata)
3950                 if ($line =~ /(\b$InitAttribute\b)/) {
3951                         my $attr = $1;
3952                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
3953                                 my $ptr = $1;
3954                                 my $var = $2;
3955                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
3956                                       ERROR("MISPLACED_INIT",
3957                                             "$attr should be placed after $var\n" . $herecurr)) ||
3958                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
3959                                       WARN("MISPLACED_INIT",
3960                                            "$attr should be placed after $var\n" . $herecurr))) &&
3961                                     $fix) {
3962                                         $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;
3963                                 }
3964                         }
3965                 }
3966
3967 # check for $InitAttributeData (ie: __initdata) with const
3968                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
3969                         my $attr = $1;
3970                         $attr =~ /($InitAttributePrefix)(.*)/;
3971                         my $attr_prefix = $1;
3972                         my $attr_type = $2;
3973                         if (ERROR("INIT_ATTRIBUTE",
3974                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
3975                             $fix) {
3976                                 $fixed[$linenr - 1] =~
3977                                     s/$InitAttributeData/${attr_prefix}initconst/;
3978                         }
3979                 }
3980
3981 # check for $InitAttributeConst (ie: __initconst) without const
3982                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
3983                         my $attr = $1;
3984                         if (ERROR("INIT_ATTRIBUTE",
3985                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
3986                             $fix) {
3987                                 my $lead = $fixed[$linenr - 1] =~
3988                                     /(^\+\s*(?:static\s+))/;
3989                                 $lead = rtrim($1);
3990                                 $lead = "$lead " if ($lead !~ /^\+$/);
3991                                 $lead = "${lead}const ";
3992                                 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
3993                         }
3994                 }
3995
3996 # don't use __constant_<foo> functions outside of include/uapi/
3997                 if ($realfile !~ m@^include/uapi/@ &&
3998                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
3999                         my $constant_func = $1;
4000                         my $func = $constant_func;
4001                         $func =~ s/^__constant_//;
4002                         if (WARN("CONSTANT_CONVERSION",
4003                                  "$constant_func should be $func\n" . $herecurr) &&
4004                             $fix) {
4005                                 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
4006                         }
4007                 }
4008
4009 # prefer usleep_range over udelay
4010                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4011                         my $delay = $1;
4012                         # ignore udelay's < 10, however
4013                         if (! ($delay < 10) ) {
4014                                 CHK("USLEEP_RANGE",
4015                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4016                         }
4017                         if ($delay > 2000) {
4018                                 WARN("LONG_UDELAY",
4019                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4020                         }
4021                 }
4022
4023 # warn about unexpectedly long msleep's
4024                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4025                         if ($1 < 20) {
4026                                 WARN("MSLEEP",
4027                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4028                         }
4029                 }
4030
4031 # check for comparisons of jiffies
4032                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4033                         WARN("JIFFIES_COMPARISON",
4034                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4035                 }
4036
4037 # check for comparisons of get_jiffies_64()
4038                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4039                         WARN("JIFFIES_COMPARISON",
4040                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4041                 }
4042
4043 # warn about #ifdefs in C files
4044 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4045 #                       print "#ifdef in C files should be avoided\n";
4046 #                       print "$herecurr";
4047 #                       $clean = 0;
4048 #               }
4049
4050 # warn about spacing in #ifdefs
4051                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4052                         if (ERROR("SPACING",
4053                                   "exactly one space required after that #$1\n" . $herecurr) &&
4054                             $fix) {
4055                                 $fixed[$linenr - 1] =~
4056                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4057                         }
4058
4059                 }
4060
4061 # check for spinlock_t definitions without a comment.
4062                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4063                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4064                         my $which = $1;
4065                         if (!ctx_has_comment($first_line, $linenr)) {
4066                                 CHK("UNCOMMENTED_DEFINITION",
4067                                     "$1 definition without comment\n" . $herecurr);
4068                         }
4069                 }
4070 # check for memory barriers without a comment.
4071                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4072                         if (!ctx_has_comment($first_line, $linenr)) {
4073                                 WARN("MEMORY_BARRIER",
4074                                      "memory barrier without comment\n" . $herecurr);
4075                         }
4076                 }
4077 # check of hardware specific defines
4078                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4079                         CHK("ARCH_DEFINES",
4080                             "architecture specific defines should be avoided\n" .  $herecurr);
4081                 }
4082
4083 # Check that the storage class is at the beginning of a declaration
4084                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4085                         WARN("STORAGE_CLASS",
4086                              "storage class should be at the beginning of the declaration\n" . $herecurr)
4087                 }
4088
4089 # check the location of the inline attribute, that it is between
4090 # storage class and type.
4091                 if ($line =~ /\b$Type\s+$Inline\b/ ||
4092                     $line =~ /\b$Inline\s+$Storage\b/) {
4093                         ERROR("INLINE_LOCATION",
4094                               "inline keyword should sit between storage class and type\n" . $herecurr);
4095                 }
4096
4097 # Check for __inline__ and __inline, prefer inline
4098                 if ($realfile !~ m@\binclude/uapi/@ &&
4099                     $line =~ /\b(__inline__|__inline)\b/) {
4100                         if (WARN("INLINE",
4101                                  "plain inline is preferred over $1\n" . $herecurr) &&
4102                             $fix) {
4103                                 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4104
4105                         }
4106                 }
4107
4108 # Check for __attribute__ packed, prefer __packed
4109                 if ($realfile !~ m@\binclude/uapi/@ &&
4110                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4111                         WARN("PREFER_PACKED",
4112                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4113                 }
4114
4115 # Check for __attribute__ aligned, prefer __aligned
4116                 if ($realfile !~ m@\binclude/uapi/@ &&
4117                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4118                         WARN("PREFER_ALIGNED",
4119                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4120                 }
4121
4122 # Check for __attribute__ format(printf, prefer __printf
4123                 if ($realfile !~ m@\binclude/uapi/@ &&
4124                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4125                         if (WARN("PREFER_PRINTF",
4126                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4127                             $fix) {
4128                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4129
4130                         }
4131                 }
4132
4133 # Check for __attribute__ format(scanf, prefer __scanf
4134                 if ($realfile !~ m@\binclude/uapi/@ &&
4135                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4136                         if (WARN("PREFER_SCANF",
4137                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4138                             $fix) {
4139                                 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4140                         }
4141                 }
4142
4143 # check for sizeof(&)
4144                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4145                         WARN("SIZEOF_ADDRESS",
4146                              "sizeof(& should be avoided\n" . $herecurr);
4147                 }
4148
4149 # check for sizeof without parenthesis
4150                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4151                         if (WARN("SIZEOF_PARENTHESIS",
4152                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4153                             $fix) {
4154                                 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4155                         }
4156                 }
4157
4158 # check for line continuations in quoted strings with odd counts of "
4159                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4160                         WARN("LINE_CONTINUATIONS",
4161                              "Avoid line continuations in quoted strings\n" . $herecurr);
4162                 }
4163
4164 # check for struct spinlock declarations
4165                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4166                         WARN("USE_SPINLOCK_T",
4167                              "struct spinlock should be spinlock_t\n" . $herecurr);
4168                 }
4169
4170 # check for seq_printf uses that could be seq_puts
4171                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4172                         my $fmt = get_quoted_string($line, $rawline);
4173                         if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4174                                 if (WARN("PREFER_SEQ_PUTS",
4175                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4176                                     $fix) {
4177                                         $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4178                                 }
4179                         }
4180                 }
4181
4182 # Check for misused memsets
4183                 if ($^V && $^V ge 5.10.0 &&
4184                     defined $stat &&
4185                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4186
4187                         my $ms_addr = $2;
4188                         my $ms_val = $7;
4189                         my $ms_size = $12;
4190
4191                         if ($ms_size =~ /^(0x|)0$/i) {
4192                                 ERROR("MEMSET",
4193                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4194                         } elsif ($ms_size =~ /^(0x|)1$/i) {
4195                                 WARN("MEMSET",
4196                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4197                         }
4198                 }
4199
4200 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4201                 if ($^V && $^V ge 5.10.0 &&
4202                     $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4203                         if (WARN("PREFER_ETHER_ADDR_COPY",
4204                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4205                             $fix) {
4206                                 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4207                         }
4208                 }
4209
4210 # typecasts on min/max could be min_t/max_t
4211                 if ($^V && $^V ge 5.10.0 &&
4212                     defined $stat &&
4213                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4214                         if (defined $2 || defined $7) {
4215                                 my $call = $1;
4216                                 my $cast1 = deparenthesize($2);
4217                                 my $arg1 = $3;
4218                                 my $cast2 = deparenthesize($7);
4219                                 my $arg2 = $8;
4220                                 my $cast;
4221
4222                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4223                                         $cast = "$cast1 or $cast2";
4224                                 } elsif ($cast1 ne "") {
4225                                         $cast = $cast1;
4226                                 } else {
4227                                         $cast = $cast2;
4228                                 }
4229                                 WARN("MINMAX",
4230                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4231                         }
4232                 }
4233
4234 # check usleep_range arguments
4235                 if ($^V && $^V ge 5.10.0 &&
4236                     defined $stat &&
4237                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4238                         my $min = $1;
4239                         my $max = $7;
4240                         if ($min eq $max) {
4241                                 WARN("USLEEP_RANGE",
4242                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4243                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4244                                  $min > $max) {
4245                                 WARN("USLEEP_RANGE",
4246                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4247                         }
4248                 }
4249
4250 # check for naked sscanf
4251                 if ($^V && $^V ge 5.10.0 &&
4252                     defined $stat &&
4253                     $line =~ /\bsscanf\b/ &&
4254                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4255                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4256                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4257                         my $lc = $stat =~ tr@\n@@;
4258                         $lc = $lc + $linenr;
4259                         my $stat_real = raw_line($linenr, 0);
4260                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
4261                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4262                         }
4263                         WARN("NAKED_SSCANF",
4264                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4265                 }
4266
4267 # check for new externs in .h files.
4268                 if ($realfile =~ /\.h$/ &&
4269                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4270                         if (CHK("AVOID_EXTERNS",
4271                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4272                             $fix) {
4273                                 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4274                         }
4275                 }
4276
4277 # check for new externs in .c files.
4278                 if ($realfile =~ /\.c$/ && defined $stat &&
4279                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4280                 {
4281                         my $function_name = $1;
4282                         my $paren_space = $2;
4283
4284                         my $s = $stat;
4285                         if (defined $cond) {
4286                                 substr($s, 0, length($cond), '');
4287                         }
4288                         if ($s =~ /^\s*;/ &&
4289                             $function_name ne 'uninitialized_var')
4290                         {
4291                                 WARN("AVOID_EXTERNS",
4292                                      "externs should be avoided in .c files\n" .  $herecurr);
4293                         }
4294
4295                         if ($paren_space =~ /\n/) {
4296                                 WARN("FUNCTION_ARGUMENTS",
4297                                      "arguments for function declarations should follow identifier\n" . $herecurr);
4298                         }
4299
4300                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4301                     $stat =~ /^.\s*extern\s+/)
4302                 {
4303                         WARN("AVOID_EXTERNS",
4304                              "externs should be avoided in .c files\n" .  $herecurr);
4305                 }
4306
4307 # checks for new __setup's
4308                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4309                         my $name = $1;
4310
4311                         if (!grep(/$name/, @setup_docs)) {
4312                                 CHK("UNDOCUMENTED_SETUP",
4313                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4314                         }
4315                 }
4316
4317 # check for pointless casting of kmalloc return
4318                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4319                         WARN("UNNECESSARY_CASTS",
4320                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4321                 }
4322
4323 # alloc style
4324 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4325                 if ($^V && $^V ge 5.10.0 &&
4326                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4327                         CHK("ALLOC_SIZEOF_STRUCT",
4328                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4329                 }
4330
4331 # check for krealloc arg reuse
4332                 if ($^V && $^V ge 5.10.0 &&
4333                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4334                         WARN("KREALLOC_ARG_REUSE",
4335                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4336                 }
4337
4338 # check for alloc argument mismatch
4339                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4340                         WARN("ALLOC_ARRAY_ARGS",
4341                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4342                 }
4343
4344 # check for multiple semicolons
4345                 if ($line =~ /;\s*;\s*$/) {
4346                         if (WARN("ONE_SEMICOLON",
4347                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
4348                             $fix) {
4349                                 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4350                         }
4351                 }
4352
4353 # check for case / default statements not preceeded by break/fallthrough/switch
4354                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4355                         my $has_break = 0;
4356                         my $has_statement = 0;
4357                         my $count = 0;
4358                         my $prevline = $linenr;
4359                         while ($prevline > 1 && $count < 3 && !$has_break) {
4360                                 $prevline--;
4361                                 my $rline = $rawlines[$prevline - 1];
4362                                 my $fline = $lines[$prevline - 1];
4363                                 last if ($fline =~ /^\@\@/);
4364                                 next if ($fline =~ /^\-/);
4365                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4366                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4367                                 next if ($fline =~ /^.[\s$;]*$/);
4368                                 $has_statement = 1;
4369                                 $count++;
4370                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4371                         }
4372                         if (!$has_break && $has_statement) {
4373                                 WARN("MISSING_BREAK",
4374                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4375                         }
4376                 }
4377
4378 # check for switch/default statements without a break;
4379                 if ($^V && $^V ge 5.10.0 &&
4380                     defined $stat &&
4381                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4382                         my $ctx = '';
4383                         my $herectx = $here . "\n";
4384                         my $cnt = statement_rawlines($stat);
4385                         for (my $n = 0; $n < $cnt; $n++) {
4386                                 $herectx .= raw_line($linenr, $n) . "\n";
4387                         }
4388                         WARN("DEFAULT_NO_BREAK",
4389                              "switch default: should use break\n" . $herectx);
4390                 }
4391
4392 # check for gcc specific __FUNCTION__
4393                 if ($line =~ /\b__FUNCTION__\b/) {
4394                         if (WARN("USE_FUNC",
4395                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
4396                             $fix) {
4397                                 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4398                         }
4399                 }
4400
4401 # check for use of yield()
4402                 if ($line =~ /\byield\s*\(\s*\)/) {
4403                         WARN("YIELD",
4404                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
4405                 }
4406
4407 # check for comparisons against true and false
4408                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4409                         my $lead = $1;
4410                         my $arg = $2;
4411                         my $test = $3;
4412                         my $otype = $4;
4413                         my $trail = $5;
4414                         my $op = "!";
4415
4416                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4417
4418                         my $type = lc($otype);
4419                         if ($type =~ /^(?:true|false)$/) {
4420                                 if (("$test" eq "==" && "$type" eq "true") ||
4421                                     ("$test" eq "!=" && "$type" eq "false")) {
4422                                         $op = "";
4423                                 }
4424
4425                                 CHK("BOOL_COMPARISON",
4426                                     "Using comparison to $otype is error prone\n" . $herecurr);
4427
4428 ## maybe suggesting a correct construct would better
4429 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4430
4431                         }
4432                 }
4433
4434 # check for semaphores initialized locked
4435                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4436                         WARN("CONSIDER_COMPLETION",
4437                              "consider using a completion\n" . $herecurr);
4438                 }
4439
4440 # recommend kstrto* over simple_strto* and strict_strto*
4441                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4442                         WARN("CONSIDER_KSTRTO",
4443                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
4444                 }
4445
4446 # check for __initcall(), use device_initcall() explicitly please
4447                 if ($line =~ /^.\s*__initcall\s*\(/) {
4448                         WARN("USE_DEVICE_INITCALL",
4449                              "please use device_initcall() instead of __initcall()\n" . $herecurr);
4450                 }
4451
4452 # check for various ops structs, ensure they are const.
4453                 my $struct_ops = qr{acpi_dock_ops|
4454                                 address_space_operations|
4455                                 backlight_ops|
4456                                 block_device_operations|
4457                                 dentry_operations|
4458                                 dev_pm_ops|
4459                                 dma_map_ops|
4460                                 extent_io_ops|
4461                                 file_lock_operations|
4462                                 file_operations|
4463                                 hv_ops|
4464                                 ide_dma_ops|
4465                                 intel_dvo_dev_ops|
4466                                 item_operations|
4467                                 iwl_ops|
4468                                 kgdb_arch|
4469                                 kgdb_io|
4470                                 kset_uevent_ops|
4471                                 lock_manager_operations|
4472                                 microcode_ops|
4473                                 mtrr_ops|
4474                                 neigh_ops|
4475                                 nlmsvc_binding|
4476                                 pci_raw_ops|
4477                                 pipe_buf_operations|
4478                                 platform_hibernation_ops|
4479                                 platform_suspend_ops|
4480                                 proto_ops|
4481                                 rpc_pipe_ops|
4482                                 seq_operations|
4483                                 snd_ac97_build_ops|
4484                                 soc_pcmcia_socket_ops|
4485                                 stacktrace_ops|
4486                                 sysfs_ops|
4487                                 tty_operations|
4488                                 usb_mon_operations|
4489                                 wd_ops}x;
4490                 if ($line !~ /\bconst\b/ &&
4491                     $line =~ /\bstruct\s+($struct_ops)\b/) {
4492                         WARN("CONST_STRUCT",
4493                              "struct $1 should normally be const\n" .
4494                                 $herecurr);
4495                 }
4496
4497 # use of NR_CPUS is usually wrong
4498 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4499                 if ($line =~ /\bNR_CPUS\b/ &&
4500                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4501                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4502                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4503                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4504                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4505                 {
4506                         WARN("NR_CPUS",
4507                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4508                 }
4509
4510 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4511                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4512                         ERROR("DEFINE_ARCH_HAS",
4513                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4514                 }
4515
4516 # check for %L{u,d,i} in strings
4517                 my $string;
4518                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4519                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4520                         $string =~ s/%%/__/g;
4521                         if ($string =~ /(?<!%)%L[udi]/) {
4522                                 WARN("PRINTF_L",
4523                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4524                                 last;
4525                         }
4526                 }
4527
4528 # whine mightly about in_atomic
4529                 if ($line =~ /\bin_atomic\s*\(/) {
4530                         if ($realfile =~ m@^drivers/@) {
4531                                 ERROR("IN_ATOMIC",
4532                                       "do not use in_atomic in drivers\n" . $herecurr);
4533                         } elsif ($realfile !~ m@^kernel/@) {
4534                                 WARN("IN_ATOMIC",
4535                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4536                         }
4537                 }
4538
4539 # check for lockdep_set_novalidate_class
4540                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4541                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
4542                         if ($realfile !~ m@^kernel/lockdep@ &&
4543                             $realfile !~ m@^include/linux/lockdep@ &&
4544                             $realfile !~ m@^drivers/base/core@) {
4545                                 ERROR("LOCKDEP",
4546                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4547                         }
4548                 }
4549
4550                 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4551                     $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4552                         WARN("EXPORTED_WORLD_WRITABLE",
4553                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4554                 }
4555
4556 # Mode permission misuses where it seems decimal should be octal
4557 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
4558                 if ($^V && $^V ge 5.10.0 &&
4559                     $line =~ /$mode_perms_search/) {
4560                         foreach my $entry (@mode_permission_funcs) {
4561                                 my $func = $entry->[0];
4562                                 my $arg_pos = $entry->[1];
4563
4564                                 my $skip_args = "";
4565                                 if ($arg_pos > 1) {
4566                                         $arg_pos--;
4567                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4568                                 }
4569                                 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4570                                 if ($line =~ /$test/) {
4571                                         my $val = $1;
4572                                         $val = $6 if ($skip_args ne "");
4573
4574                                         if ($val !~ /^0$/ &&
4575                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4576                                              length($val) ne 4)) {
4577                                                 ERROR("NON_OCTAL_PERMISSIONS",
4578                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4579                                         }
4580                                 }
4581                         }
4582                 }
4583         }
4584
4585         # If we have no input at all, then there is nothing to report on
4586         # so just keep quiet.
4587         if ($#rawlines == -1) {
4588                 exit(0);
4589         }
4590
4591         # In mailback mode only produce a report in the negative, for
4592         # things that appear to be patches.
4593         if ($mailback && ($clean == 1 || !$is_patch)) {
4594                 exit(0);
4595         }
4596
4597         # This is not a patch, and we are are in 'no-patch' mode so
4598         # just keep quiet.
4599         if (!$chk_patch && !$is_patch) {
4600                 exit(0);
4601         }
4602
4603         if (!$is_patch) {
4604                 ERROR("NOT_UNIFIED_DIFF",
4605                       "Does not appear to be a unified-diff format patch\n");
4606         }
4607         if ($is_patch && $chk_signoff && $signoff == 0) {
4608                 ERROR("MISSING_SIGN_OFF",
4609                       "Missing Signed-off-by: line(s)\n");
4610         }
4611
4612         print report_dump();
4613         if ($summary && !($clean == 1 && $quiet == 1)) {
4614                 print "$filename " if ($summary_file);
4615                 print "total: $cnt_error errors, $cnt_warn warnings, " .
4616                         (($check)? "$cnt_chk checks, " : "") .
4617                         "$cnt_lines lines checked\n";
4618                 print "\n" if ($quiet == 0);
4619         }
4620
4621         if ($quiet == 0) {
4622
4623                 if ($^V lt 5.10.0) {
4624                         print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4625                         print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4626                 }
4627
4628                 # If there were whitespace errors which cleanpatch can fix
4629                 # then suggest that.
4630                 if ($rpt_cleaners) {
4631                         print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4632                         print "      scripts/cleanfile\n\n";
4633                         $rpt_cleaners = 0;
4634                 }
4635         }
4636
4637         hash_show_words(\%use_type, "Used");
4638         hash_show_words(\%ignore_type, "Ignored");
4639
4640         if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4641                 my $newfile = $filename;
4642                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4643                 my $linecount = 0;
4644                 my $f;
4645
4646                 open($f, '>', $newfile)
4647                     or die "$P: Can't open $newfile for write\n";
4648                 foreach my $fixed_line (@fixed) {
4649                         $linecount++;
4650                         if ($file) {
4651                                 if ($linecount > 3) {
4652                                         $fixed_line =~ s/^\+//;
4653                                         print $f $fixed_line. "\n";
4654                                 }
4655                         } else {
4656                                 print $f $fixed_line . "\n";
4657                         }
4658                 }
4659                 close($f);
4660
4661                 if (!$quiet) {
4662                         print << "EOM";
4663 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4664
4665 Do _NOT_ trust the results written to this file.
4666 Do _NOT_ submit these changes without inspecting them for correctness.
4667
4668 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4669 No warranties, expressed or implied...
4670
4671 EOM
4672                 }
4673         }
4674
4675         if ($clean == 1 && $quiet == 0) {
4676                 print "$vname has no obvious style problems and is ready for submission.\n"
4677         }
4678         if ($clean == 0 && $quiet == 0) {
4679                 print << "EOM";
4680 $vname has style problems, please review.
4681
4682 If any of these errors are false positives, please report
4683 them to the maintainer, see CHECKPATCH in MAINTAINERS.
4684 EOM
4685         }
4686
4687         return $clean;
4688 }